Java 8. כל מה שאתה צריך

מדריך Java 8

"ג'אווה עדיין חיה ואנשים מתחילים להבין את זה."

ברוכים הבאים למבוא שלי ל-Java 8. מאמר זה ייקח אתכם צעד אחר צעד דרך כל התכונות החדשות מ-Java 7 ועד Java 8. בעזרת דוגמאות קוד מהירות ופשוטות, נוכל ללמוד כיצד להשתמש בממשקי ברירת מחדל, בהפניות לשיטות , ו הערות החוזרות על עצמן . בסוף המאמר נכיר את ה- Stream API. בלי פטפוטים מיותרים - רק קוד והערות! קָדִימָה!

שיטות ברירת מחדל עבור ממשקים

Java 8 מאפשרת לנו להוסיף שיטות לא מופשטות (שמיושמות) לממשקים על ידי הוספת ה- default. תכונה זו ידועה גם בשם שיטות הרחבה . להלן הדוגמה הראשונה:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

בנוסף לשיטה המופשטת calculate, הממשק Formulaמגדיר גם שיטת ברירת מחדל sqrt. מחלקות שמיישמות ממשק זה צריכות רק ליישם את ה calculate. ניתן להשתמש בשיטת ברירת המחדל sqrtמחוץ לקופסה.

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

הממשק Formulaמיושם כמחלקה אנונימית. הקוד מיותר: 6 שורות ליישום sqrt(a * 100). כפי שנראה בסעיף הבא, יש דרך יפה יותר ליישם שיטה אחת ב-Java 8.

ביטויי למדה

נתחיל עם דוגמה פשוטה למיון רשימת מחרוזות בגרסאות קודמות של Java:

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

השיטה הסטטית Collections.sortמקבלת רשימה ומשווה לפי סדר מיון הרשימה. אתה תמיד יכול ליצור כיתת השוואה אנונימית ולהעביר אותה. במקום ליצור מחלקה אנונימית, ב-Java 8 ניתן לכתוב טופס קצר יותר, ביטוי למבדה.

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

כפי שאתה יכול לראות הקוד הרבה יותר קצר וקל יותר לקריאה. אבל אפשר לעשות את זה אפילו יותר קצר:

Collections.sort(names, (String a, String b) -> b.compareTo(a));

עבור גוף עם שורה אחת, אתה יכול לדלג על {}המילה return. אבל אתה יכול לעשות את זה אפילו יותר קצר:

Collections.sort(names, (a, b) -> b.compareTo(a));

מהדר Java יודע על סוגי ארגומנטים, אז אתה יכול לדלג עליהם גם כן. בואו נעמיק בביטויי למבדה ונבין כיצד ניתן להשתמש בהם.

ממשקים פונקציונליים

כיצד ביטויי למבדה מתאימים למערכת מסוג Java? כל למבדה מתאימה לסוג המתואר בממשק. לכן, ממשק פונקציונלי צריך להכיל רק שיטה מופשטת אחת. כל ביטוי למבדה מסוג זה יתאים לשיטה מופשטת זו. מכיוון ששיטות ברירת המחדל אינן מופשטות, אתה חופשי ליצור שיטות ברירת מחדל בממשקים פונקציונליים לפי הצורך. אנו יכולים גם להשתמש בממשקים שרירותיים כביטויי למבדה אם יש רק שיטה מופשטת אחת בממשק זה. כדי לעמוד בדרישות אלה, עליך להוסיף @FucntionalInterfaceהערה. המהדר יודע על זה ויזרוק חריג אם אתה רוצה לספק יותר משיטה מופשטת אחת. דוגמא:

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

זכור שהקוד יתבצע גם אם @FunctionalInterfaceיושמט ההערה.

הפניות של שיטה ובנאי

ניתן גם להקטין את הדוגמה שלמעלה על ידי שימוש בהפניות לשיטה:

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 מאפשר לך להעביר הפניות לשיטה או בנאי על ידי הוספת ::. הדוגמה שלמעלה מראה כיצד אנו יכולים להתייחס לשיטה סטטית, אם כי אנו יכולים להתייחס גם לשיטות לא סטטיות:

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

בוא נראה איך ::זה עובד עם בנאים. כדי להתחיל, נגדיר מחלקה לדוגמה עם בנאים שונים:

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

לאחר מכן, נגדיר ממשק ליצירת אובייקטים חדשים:

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

במקום להטמיע מפעל יצירה, נקשור את הכל יחד בעזרת ::הקונסטרוקטור:

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

יצרנו קישור לבנאי באמצעות Person::new. מהדר Java יבחר אוטומטית את הבנאי הנכון שתואם את חתימת השיטה PersonFactory.create. ... המשך יבוא. לצערי, לא מצאתי דרך לשמור טיוטה של ​​המאמר, וזה ממש מוזר, והזמן לתרגום נגמר - אז אסיים אותו מאוחר יותר. לכל מי שיודע ומבין באנגלית - מאמר מקורי . אם יש לך הצעות לתיקון התרגום, כתוב בכל דרך העומדת לרשותך. חשבון Github שלי