class Point {
    int x;
    int y;
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }
    
    boolean filter() {
        return this.x == this.y;
    }
    
}
 
public class Test {
    public static void main(String[] args) {
        List<Point> list = new ArrayList<>();
        list.add(new Point(0, 0));
        list.add(new Point(1, 2));
        list.add(new Point(-1, -1));
        Supplier<Boolean> s = Point::filter; // Compilation Error (line n1)
        list.stream().filter(Point::filter).forEach(System.out::println); //No Error (line n2)
    }
}

On Line N2, jeśli uzyskaj dostęp do metody instancji za pomocą nazwy klasy, a następnie domyślnie, arbitralny obiekt jest tworzony dostęp do dostępu, ale w wierszu N1, otrzymuję błąd kompilacji. W jakich scenariuszach tworzone są arbitralne domyślne obiekty?

Nie otrzymuję błędu, jeśli używam obiektu

new Point(0,0)::filter
0
Jon B 15 marzec 2021, 10:01

1 odpowiedź

Najlepsza odpowiedź

W jakich scenariuszach tworzone są arbitralne domyślne obiekty?

W ani scenariusz , czy nowe obiekty są tworzone.

Supplier<Boolean> s = Point::filter; nie jest kompiluje, ponieważ Supplier<Boolean> reprezentuje funkcję, która może dać Ci Boolean} bez podania jej żadnych wejść :

Boolean b = s.get(); // note that I am not giving "get" any input
// but s refers to the filter method in Point, which is an instance method
// I don't have any Point object in my code, yet somehow I still got a Boolean,
//  so clearly this doesn't make sense

Jak widać, Point::filter nie jest taką funkcją. Nazywać to, musiałbym przed obiektem Point, a potem dałoby mi boolean. Predicate<Point> to interfejs funkcjonalny, który może reprezentować ten rodzaj funkcji, więc mogę to zrobić:

Predicate<Point> pred = Point::filter;
boolean b = pred.test(new Point(0, 0)); // here I am giving red the instance of Point on which filter should be called

Zauważ, jak nie określasz, który obiekt filter powinien być wywoływany w odniesieniu do metody (Point::filter), ale raczej jest określony przez dzwoniącego (pred.test(...)). Dlatego Point::filter jest nazywany "odniesieniem do metody instancji arbitralne obiekt".

Wreszcie, powód, dla którego Stream.filter może przyjąć metodę Point::filter jest dlatego, że

Sweeper 15 marzec 2021, 07:26