public class Godness {

    private String name;

    public Godness() {
    }

    public Godness(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public
 
 String toString() {
        return "Godness [name=" + name + "]";
    }

}

public class Man {

    private Godness god;

    public Man() {
    }

    public Man(Godness god) {
        this.god = god;
    }

    public Godness getGod() {
        return god;
    }

    public void setGod(Godness god) {
        
 
this.god = god;
    }

    @Override
    public String toString() {
        return "Man [god=" + god + "]";
    }

}

import java.util.Optional;

//註意：Optional 不能被序列化
public class NewMan {

    private Optional<Godness> godness = Optional.empty();
    
    private Godness god;
    
    public
 
 Optional<Godness> getGod(){
        return Optional.of(god);
    }

    public NewMan() {
    }

    public NewMan(Optional<Godness> godness) {
        this.godness = godness;
    }

    public Optional<Godness> getGodness() {
        return godness;
    }

    public void setGodness(Optional<Godness> godness) {
        this.godness = godness;
    }

    @Override
    public String toString() {
        return "NewMan [godness=" + godness + "]";
    }

}

import java.util.Optional;

import org.junit.Test;

/*
 * 一、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 test4(){
        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 test3(){
        Optional<Employee> op = Optional.ofNullable(new Employee());
        
        if(op.isPresent()){
            System.out.println(op.get());
        }
        
        Employee emp = op.orElse(new Employee("張三"));
        System.out.println(emp);
        
        Employee emp2 = op.orElseGet(() -> new Employee());
        System.out.println(emp2);
    }
    
    @Test
    public void test2(){
        /*Optional<Employee> op = Optional.ofNullable(null);
        System.out.println(op.get());*/
        
//        Optional<Employee> op = Optional.empty();
//        System.out.println(op.get());
    }

    @Test
    public void test1(){
        Optional<Employee> op = Optional.of(new Employee());
        Employee emp = op.get();
        System.out.println(emp);
    }
    
    @Test
    public void test5(){
        Man man = new Man();
        
        String name = getGodnessName(man);
        System.out.println(name);
    }
    
    //需求：獲取一個男人心中女神的名字
    public String getGodnessName(Man man){
        if(man != null){
            Godness g = man.getGod();
            
            if(g != null){
                return g.getName();
            }
        }
        
        return "蒼老師";
    }
    
    //運用 Optional 的實體類
    @Test
    public void test6(){
        Optional<Godness> godness = Optional.ofNullable(new Godness("林誌玲"));
        
        Optional<NewMan> op = Optional.ofNullable(new NewMan(godness));
        String name = getGodnessName2(op);
        System.out.println(name);
    }
    
    public String getGodnessName2(Optional<NewMan> man){
        return man.orElse(new NewMan())
                  .getGodness()
                  .orElse(new Godness("蒼老師"))
                  .getName();
    }
}

java8 新特性 Optional容器類