Với 'T` và' U` nơi 'T kéo dài U` làm thế nào để trả về một' U`

Question

Với một API như:

class Bar { ... } 
class Foo extends Bar { ... } 

Trong Optional loại Java, chúng ta có thể nói:

Optional<Foo> fooOption = ... 
fooOption.orElse(aFoo) // returns something of type Foo 

Nhưng, kể từ Foo là một Bar, tôi muốn để có thể nói:

Optional<Foo> fooOption = ... 
fooOption.orElse(aBar) // returns something of type Bar 

là một tập thể dục, tôi wa nted để thực hiện điều này với loại khác:

public abstract class Option<T> { 
    // this doesn't compile 
    public abstract <U super T> U orElse(U other); 
} 

Làm thế nào tôi sẽ viết lại này để biên dịch, mà còn hỗ trợ khả năng mở rộng các loại khi mong muốn cùng một lúc?

Answer 1

Nhưng, kể từ Foo là một Bar

Nhưng Bar không phải là một Foo. Những gì tôi có nghĩa là bạn có thể làm điều này:

Optional<Bar> fooOpt = Optional.of(new Foo()); 
Bar bar = fooOpt.orElse(new Bar()); 

Nhưng bạn không thể làm điều tương tự với Optional<Foo> vì nó vi phạm gõ hạn chế của phương pháp Optional.orElse.

Thực hiện giả thuyết của Option<T> bạn nên xác định một cách rõ ràng U như một supertype của T

public class Option<U, T extends U> { 
    T value; 

    public U orElse(U other) { 
     if (value != null) { 
      return value; 
     } 
     return other; 
    } 
} 

Trong trường hợp đó bạn có thể viết một mã như thế này

Option<Foo, Bar> fooOpt = Option.of(new Foo()); 
Bar bar = fooOpt.orElse(new Bar()); 

Answer 2

Kể từ U nên là siêu loại T, bạn có thể làm:

public abstract class Option<U, T extends U> { 

    public abstract of(T value); 

    public abstract U orElse(U other); 

} 

Answer 3

Có một tiền đề cơ bản mà là thiếu sót trong câu hỏi của bạn:

Trong loại tùy chọn của Java, chúng ta có thể nói:

Tùy chọn fooOption = ... fooOption.orElse (aFoo) // returns một cái gì đó của loại Foo Nhưng, vì Foo là một Bar, tôi muốn để có thể nói:

fooOption Tùy chọn = ... fooOption.orElse (Abar) // trả về một cái gì đó kiểu Bar

A Foo là một Bar, nhưng Bar không phải là một Foo. Nếu Chung của bạn được định nghĩa là:

Optional<Foo> fooOption = ... 

Sau đó, bạn có thể trả lại bất kỳ thứ gì thuộc loại Foo. A Bar là không phải loại Foo.

Nếu bạn đã có một đối tượng bổ sung:

class FooBar extends Foo{} 

Sau đó, bạn có thể bỏ nó vào một foo trong ví dụ của bạn:

Tùy chọn fooOption = ...

fooOption.orElse (aFooBar) // trả về một cái gì đó thuộc loại Foo

Hoặc, optiona lly, nếu bạn đã xác định Optional là Optional<Bar> thì bạn có thể sử dụng các đối tượng Foo hoặc Bar hoặc FooBar vì tất cả đều là hoặc được kế thừa từ loại Bar.

Đối với phần thứ hai của câu hỏi của bạn:

public abstract class Option<T> { 
    // this doesn't compile 
    public abstract <U super T> U orElse(U other); 
} 

Chỉ cần bằng cách viết này với siêu kiểu chung:

public abstract class Option<T> { 
    // this now compiles. 
    public abstract T orElse(T other); 
} 

Bạn đang nói rằng bất cứ điều gì đó là của hoặc kế thừa từ loại T là chấp nhận được.

Answer 4

Bạn có thể xác định phương pháp của riêng bạn sử dụng map để mở rộng loại:

public static <U, T extends U> U orElse(Optional<T> tOpt, U u) { 
    return tOpt.<U>map(Function.identity()).orElse(u); 
}