جاوا 8. هر آنچه شما نیاز دارید

آموزش جاوا 8

جاوا هنوز زنده است و مردم شروع به درک آن کرده اند.

به آشنایی من با جاوا 8 خوش آمدید. این مقاله شما را به صورت گام به گام با تمام ویژگی های جدید از جاوا 7 تا جاوا 8 آشنا می کند. با مثال های کد سریع و ساده، می توانیم نحوه استفاده از رابط های پیش فرض، مراجع روش ، و حاشیه نویسی های تکراری در پایان مقاله با Stream API آشنا می شویم. بدون صحبت های غیر ضروری - فقط کد و نظرات! رو به جلو!

روش های پیش فرض برای رابط ها

جاوا 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). همانطور که در بخش بعدی خواهیم دید، یک روش زیباتر برای پیاده سازی یک متد در جاوا 8 وجود دارد.

عبارات لامبدا

بیایید با یک مثال ساده از مرتب‌سازی لیست رشته‌ها در نسخه‌های قبلی جاوا شروع کنیم:

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یک لیست و یک مقایسه کننده را به ترتیبی که فهرست قرار است مرتب شود می پذیرد. همیشه می توانید یک کلاس مقایسه کننده ناشناس ایجاد کنید و آن را ارسال کنید. به جای ایجاد یک کلاس ناشناس، در جاوا 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));

کامپایلر جاوا انواع آرگومان ها را می شناسد، بنابراین می توانید آنها را نیز نادیده بگیرید. بیایید عبارات لامبدا را عمیق تر کنیم و بفهمیم که چگونه می توان از آنها استفاده کرد.

رابط های کاربردی

چگونه عبارات لامبدا در سیستم نوع جاوا قرار می گیرند؟ هر لامبدا مربوط به یک نوع توصیف شده در رابط است. بنابراین، یک رابط کاربردی باید فقط یک روش انتزاعی داشته باشد. هر عبارت لامبدا از این نوع با این روش انتزاعی مطابقت دارد. از آنجایی که روش‌های پیش‌فرض انتزاعی نیستند، می‌توانید در صورت نیاز روش‌های پیش‌فرض را در رابط‌های کاربردی ایجاد کنید. اگر فقط یک روش انتزاعی در این رابط وجود داشته باشد، می‌توانیم از رابط‌های دلخواه به عنوان عبارات لامبدا استفاده کنیم. برای برآورده کردن این الزامات، باید @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

جاوا 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. کامپایلر جاوا به طور خودکار سازنده صحیح را انتخاب می کند که با امضای متد مطابقت داشته باشد PersonFactory.create. ... ادامه دارد. متأسفانه راهی برای ذخیره پیش نویس مقاله پیدا نکردم و این واقعاً عجیب است و زمان ترجمه به پایان رسیده است - بنابراین بعداً آن را تمام می کنم. برای همه کسانی که انگلیسی می دانند و می دانند - مقاله اصلی . اگر پیشنهادی برای تصحیح ترجمه دارید، به هر شکلی که در اختیار دارید بنویسید. حساب Github من