Android phone with java

Jake Wharton

Android’s Java 9, 10, 11, and 12 Support

27 November 2018

Note: This post is part of a series on D8 and R8, Android’s new dexer and optimizer, respectively. For an intro to D8 read “Android’s Java 8 support”.

The first post in this series explored Android’s Java 8 support. Having support for the language features and APIs of Java 8 is table stakes at this point. We’re not quite there with the APIs yet, sadly, but D8 has us covered with the language features. There’s a future promise for the APIs which is essential for the health of the ecosystem.

A lot of the reaction to the previous post echoed that Java 8 is quite old. The rest of the Java ecosystem is starting to move to Java 11 (being the first long-term supported release after 8) after having toyed with Java 9 and 10. I was hoping for that reaction because I mostly wrote that post so that I could set up this one.

With Java releases happening more frequently, Android’s yearly release schedule and delayed uptake of newer language features and APIs feels more painful. But is it actually the case that we’re stuck with those of Java 8? Let’s take a look at the Java releases beyond 8 and see how the Android toolchain fares.

Java 9

The last release on the 2 — 3 year schedule, Java 9 contains a few new language features. None of them are major like lambdas were. Instead, this release focused on cleaning up some of the sharp edges on existing features.

Concise Try With Resources

Prior to this release the try-with-resources construct required that you define a local variable (such as try (Closeable bar = foo.bar()) ). But if you already have a Closeable , defining a new variable is redundant. As such, this release allows you to omit declaring a new variable if you already have an effectively-final reference.

This feature is implemented entirely in the Java compiler so D8 is able to dex it for Android.

Unlike the lambdas or static interface methods of Java 8 which required special desugaring, this Java 9 feature becomes available to all API levels for free.

Anonymous Diamond

Java 7 introduced the diamond operator which allowed omitting a generic type from the initializer if it could be inferred from the variable type.

This cut down on redundant declarations, but it wasn’t available for use on anonymous classes. With Java 9 that is now supported.

Once again this is entirely implemented in the Java compiler so the resulting bytecode is as if String was explicitly specified.

Because there is nothing interesting in the bytecode, D8 handles this without issue.

Yet another language feature available to all API levels for free.

Private Interface Methods

Interfaces with multiple static or default methods can often lead to duplicated code in their bodies. If these methods were part of a class and not an interface private helper functions could be extracted. Java 9 adds the ability for interfaces to contain private methods which are only accessible to its static and default methods.

This is the first language feature that requires some kind of support. Prior to this release, the private modifier was not allowed on an interface member. Since D8 is already responsible for desugaring default and static methods, private methods were straightforward to include using the same technique.

Static and default methods are supported natively in ART as of API 24. When you pass —min-api 24 for this example, the static method is not desugared. Curiously, though, the private static method is also not desugared.

We can see that the getHey() method’s access flags still contain both PRIVATE and STATIC . If you add a main method which calls hey() and push this to a device it will actually work. Despite being a feature added in Java 9, ART allows private interface members since API 24!

Those are all the language features of Java 9 and they all already work on Android. How about that.

The APIs of Java 9, though, are not yet included in the Android SDK. A new process API, var handles, a version of the Reactive Streams interfaces, and collection factories are just some of those which were added. Since libcore (which contains implementation of java.* ) and ART are developed in AOSP, we can peek and see that work is already underway towards supporting Java 9. Once included included in the SDK, some of its APIs will be candidates for desugaring to all API levels.

String Concat

The new language features and APIs of a Java release tend to be what we talk about most. But each release is also an opportunity to optimize the bytecode which is used to implement a feature. Java 9 brought an optimization to a ubiquitous language feature: string concatenation.

If we take this fairly innocuous piece of code and compile it with Java 8 the resulting bytecode will use a StringBuilder .

The bytecode contains the code we otherwise would have written if the language didn’t allow simple concatenation.

If we change the compiler to Java 9, however, the result is very different.

The entire StringBuilder usage has been replaced with a single invokedynamic bytecode! The behavior here is similar to how native lambdas work on the JVM which was discussed in the last post.

At runtime, on the JVM, the JDK class StringConcatFactory is responsible for returning a block of code which can efficiently concatenate the arguments and constants together. This allows the implementation to change over time without the code having to be recompiled. It also means that the StringBuilder can be pre-sized more accurately since the argument’s lengths can be queried.

If you want to learn more about why this change was made, Aleksey ShipilГ«v gave a great presentation on the motivations, implementation, and resulting benchmarks of the change.

Since the Android APIs don’t yet include anything from Java 9, there is no StringConcatFactory available at runtime. Thankfully, just like it did for LambdaMetafactory and lambdas, D8 is able to desugar StringConcatFactory for concatenations.

This means that all of the language features of Java 9 can be used on all API levels of Android despite changes in the bytecode that the Java compiler emits.

But Java is now on a six-month release schedule making Java 9 actually two versions old. Can we keep it going with newer versions?

Читайте также:  Usb web camera для android

Java 10

The only language feature of Java 10 was called local-variable type inference. This allows you to omit the type of local variable by replacing it with var when that type can be inferred.

This is another feature implemented entirely in the Java compiler.

No new bytecodes or runtime APIs are required for this feature to work and so it can be used for Android just fine.

Of course, like the versions of Java before it, there are new APIs in this release such as Optional.orElseThrow , List.copyOf , and Collectors.toUnmodifiableList . Once added to the Android SDK in a future API level, these APIs can be trivially desugared to run on all API levels.

Java 11

Local-variable type inference was enhanced in Java 11 to support its use on lambda variables. You don’t see types used in lambda parameters often so a lot of people don’t even know this syntax exists. This is useful when you need to provide an explicit type to help type inference or when you want to use a type-annotation on the parameter.

Just like Java 10’s local-variable type inference this feature is implemented entirely in the Java compiler allowing it to work on Android.

New APIs in Java 11 include a bunch of new helpers on String , Predicate.not , and null factories for Reader , Writer , InputSteam , and OutputStream . Nearly all of the API additions in this release could be trivially desugared once available.

A major API addition to Java 11 is the new HTTP client, java.net.http . This client was previously available experimentally in the jdk.incubator.http package since Java 9. This is a very large API surface and implementation which leverages CompletableFuture extensively. It will be interesting to see whether or not this even lands in the Android SDK let alone is available via desugaring.

Nestmates

Like Java 9 and its string concatenation bytecode optimization, Java 11 took the opportunity to fix a long-standing disparity between Java’s source code and its class files and the JVM: nested classes.

In Java 1.1, nested classes were added to the language but not the class specification or JVM. In order to work around the lack of support in class file, nesting classes in a source file instead creates sibling classes which use a naming convention to convey nesting.

Compiling this with Java 10 or earlier will produce two class files from a single source file.

As far as the JVM is concerned, these classes have no relationship except that they exist in the same package.

This illusion mostly works. Where it starts to break down is when one of the classes needs to access something that is private in the other.

When these classes are made siblings, Outer$Inner.sayHi() is unable to access Outer.name because it is private to another class.

In order to work around this problem and maintain the nesting illusion, the Java compiler adds a package-private synthetic accessor method for any member accessed across this boundary.

This is visible in the compiled class file for Outer .

Historically this has been at most a small annoyance on the JVM. For Android, though, these synthetic accessor methods contribute to the method count in our dex files, increase APK size, slow down class loading and verification, and degrade performance by turning a field lookup into a method call!

In Java 11, the class file format was updated to introduce the concept of nests to describe these nesting relationships.

The output here has been trimmed significantly, but the two class files are still produced except without an access$000 in Outer and with new NestMembers and NestHost attributes. These allow the VM to enforce a level of access control between package-private and private called nestmates. As a result, Inner can directly access Outer ’s name field.

ART does not understand the concept of nestmates so it needs to be desugared back into synthetic accessor methods.

Unfortunately, at the time of writing, this does not work. The version of ASM, the library used to read Java class files, predates the final implementation of nestmates. Beyond that, though, D8 does not support desugaring of nest mates. You can star the D8 feature request on the Android issue tracker to convey your support for this feature.

Without support for desugaring nestmates it is currently impossible to use Java 11 for Android. Even if you avoid accessing things across the nested boundary, the mere presence of nesting will fail to compile.

Without the APIs from Java 11 in the Android SDK, its single language feature of lambda parameter type inference isn’t compelling. For now, Android developers are not missing anything by being stuck on Java 10. That is, until we start looking forward…

Java 12

With a release date of March 2019, Java 12 is quickly approaching. The language features and APIs of this release have been in development for a few months already. Through early-access builds, we can download and experiment with these today.

In the current EA build, number 20, there are two new language features available: expression switch and string literals.

Once again, both of these features are implemented entirely as part of the Java compiler without any new bytecodes or APIs.

We can push this to a device to ensure that it actually works at runtime.

This works because the bytecode for expression switch is the same as the “regular” switch we would otherwise write with an uninitialized local, case blocks with break , and a separate return statement. And a multi-line string literal is just a string with newlines in it, something we’ve been able to do with escape characters forever.

As with all the other releases covered, there will be new APIs in Java 12 and it’s the same story as before. They’ll need added to the Android SDK and evaluated for desugaring capability.

Hopefully by the time Java 12 is actually released D8 will have implemented desugaring for Java 11’s nestmates. Otherwise the pain of being stuck on Java 10 will go up quite a bit!

Java 8 language features are here and desugaring of its APIs are coming (star the issue!). As the larger Java ecosystem moves forward to newer versions, it’s reassuring that every language feature between 8 and 12 is already available on Android.

With Java 9 work seemingly happening in AOSP (cross your fingers for Android P+1), hopefully we’ll have a new batch of APIs in the summer as candidates for desugaring. Once that lands, the smaller releases of Java will hopefully yield faster integration into the Android SDK.

Despite this, the end advice remains the same as in the last post. It’s vitally important to maintain pressure on Android for supporting the new APIs and VM features from newer versions of Java. Without APIs being integrated into the SDK they can’t (easily) be made available for use via desugaring. Without VM features being integrated into ART D8 bears a desugaring burden for all API levels instead of only to provide backwards compatibility.

Читайте также:  Навигатор для самолета андроид

Before these posts move on to talk about R8, the optimizing version of D8, the next one will cover how D8 works around version-specific and vendor-specific bugs in the VM.

(This post was adapted from a part of my Digging into D8 and R8 talk that was never presented. Watch the video and look out for future blog posts for more content like this.)

Источник

Изучаем Java для разработки для Android: введение в Java

В этой серии туториалов вы познакомитесь с Java, языком программирования, используемым для разработки приложений для Android. Наша цель — подготовить тех, кто уже знаком с одним языком программирования, таким как PHP или Objective-C, которые помогут в работе с Java и окунут вас в разработку приложений для Android. В этом уроке вы получите краткое введение в основы Java, включая объектно-ориентированное программирование, наследование и многое другое. Если вы новичок в Java или просто хотите разобраться в деталях, то этот курс для вас!

Давайте начнем

Что касается предпосылок, мы предположим, что вы понимаете, как программировать (возможно, на PHP, или Visual Basic или C ++), но вы не знакомы со спецификой программирования на языке Java. Мы не собираемся учить вас программировать; мы собираемся предоставить вам четкие примеры обычно используемых конструкций и принципов языка Java, указав на некоторые советы и трюки касательно Android.

Что вам понадобится

Технически вам не нужны какие-либо инструменты для завершения этого урока, но вам наверняка понадобится для разработки приложение на Android.

Для разработки приложений для Android (или любых приложений Java, если на то пошло) вам нужна среда разработки для написания и сборки приложений. Eclipse — очень популярная среда разработки (IDE) для Java и предпочтительная среда разработки для Android. Она доступна для операционных систем Windows, Mac и Linux.

Полные инструкции по установке Eclipse (включая поддерживаемые версии) и Android SDK см. На веб-сайте разработчика Android.

Что такое Java?

Приложения для Android разрабатываются с использованием языка Java. На данный момент это действительно ваш единственный вариант для нативных приложений. Java — очень популярный язык программирования, разработанный Sun Microsystems (теперь принадлежащий Oracle). Разработанные намного позже после C и C ++, Java включает в себя многие из мощных функций этих мощных языков программирования и устраняет некоторые из их недостатков. Тем не менее, языки программирования настолько же сильны, как и их библиотеки. Эти библиотеки существуют, чтобы помочь разработчикам создавать приложения.

Некоторые из основных основных функций Java:

  • Его легко изучить и понять
  • Он разработан, чтобы быть независимым от платформы и безопасным, так как использует
    виртуальные машины.
  • Он является объектно-ориентированным

Android сильно зависит от этих основополагающих принципов Java. Android SDK включает в себя множество стандартных Java-библиотек (библиотеки структуры данных, математические библиотеки, графические библиотеки, сетевые библиотеки и все остальное, что вам может понадобиться), а также специальные библиотеки Android, которые помогут вам разработать потрясающие приложения для Android.

Почему Java легко изучить?

Java легко изучить по целому ряду причин. Конечно, нет недостатка в ресурсах Java, которые помогут вам изучить язык, включая веб-сайты, учебные пособия, книги и классы. Java является одним из наиболее широко обсуждаемых, преподаваемых и используемых языков программирования на планете. Он используется для различных проектов программирования, независимо от их масштаба, от веб-приложений и настольных приложений до мобильных приложений.

Если вы исходите из традиционного программирования, такого как C или C ++, вы найдете синтаксис Java очень похожим. Если вы этого не сделаете, то успокойтесь, зная, что вы выбрали один из самых простых языков для изучения. Вы скоро начнете работать.

Наконец, Java является одним из самых читаемых человеком языков, под которым мы подразумеваем, что человек, который ничего не знает о программировании, может часто смотреть на некоторый Java-код и по крайней мере подозревать, что он делает. Рассмотрим следующий пример:

Если вы просто прочитаете код вслух, вы можете в значительной степени сказать, что этот фрагмент кода работает. Существует одна переменная, называемая символом. Если переменная символа равна букве a, мы сделаем что-то (вызовем метод doSomething (), или в другом случае (вызывая метод doSomethingElse ().

Почему важна независимость платформы?

Со многими языками программирования вам нужно использовать компилятор, чтобы уменьшить код на машинный язык, который может понять устройство. Хотя это хорошо, разные устройства используют разные машинные языки. Это означает, что вам нужно скомпилировать ваши приложения для каждого другого устройства или машинного языка, другими словами, ваш код не очень портативен. Это не относится к Java. Компиляторы Java преобразуют ваш код из человеческих читаемых исходных файлов Java в так называемый «байт-код» в мире Java. Они интерпретируются виртуальной машиной Java, которая работает так же, как физический процессор взаимодействует с машинным кодом, чтобы выполнить скомпилированный код. Хотя может показаться, что это неэффективно, было сделано много усилий, чтобы этот процесс был очень быстрым и эффективный. Эти усилия окупились в том, что производительность Java, как правило, уступает только C/C++ в общих сравнениях производительности языка.

Приложения Android запускаются на специальной виртуальной машине под названием Dalvik VM. Хотя сведения об этой виртуальной машине не важны для среднего разработчика, может быть полезно подумать о VM Dalvik как о пузыре, в котором работает ваше приложение для Android, позволяя вам не беспокоиться о том, является ли устройство Motorola Droid, HTC Evo, или новейший тостер под управлением Android. Вам все равно, пока устройство Dalvik VM дружелюбное, и это задача производителя устройства, а не ваша.

Почему Java безопасен?

Давайте рассмотрим эту мысль немного глубже. Поскольку приложения Java работают в оболочке, которая является виртуальной машиной, они изолированы от базового устройства. Таким образом, виртуальная машина может инкапсулировать, содержать и управлять выполнением кода безопасным образом по сравнению с языками, которые работают непосредственно с машинным кодом. Платформа Android делает шаг вперед. Каждое приложение для Android работает в операционной системе (на базе Linux), используя другую учетную запись пользователя и в своем собственном экземпляре Dalvik VM. Приложения Android тщательно контролируются операционной системой и закрываются, если они не работают правильно (например, используют слишком большую вычислительную мощность, становятся невосприимчивыми, ресурсы отходов и т. д.). Поэтому важно разрабатывать приложения, которые являются стабильными и отзывчивыми. Приложения могут общаться друг с другом с использованием четко определенных протоколов.

Компиляция кода

Как и многие языки, Java по-прежнему является скомпилированным языком, хотя он не компилирует весь путь до машинного кода. Это означает, что вы, разработчик, должны скомпилировать ваши проекты Android и упаковать их для развертывания на устройства. Среда разработки Eclipse (используемая с плагином для разработки Android) делает это довольно безболезненным процессом. В Eclipse автоматическая компиляция часто включается по умолчанию. Это означает, что каждый раз, когда вы сохраняете файл проекта, Eclipse перекомпилирует изменения для вашего пакета приложений. Вы сразу видите ошибки компиляции. Eclipse также интерпретирует Java по мере ввода, обеспечивая удобную окраску и форматирование кода, а также показывающие многие типы ошибок, когда вы идете. Часто вы можете щелкнуть по ошибке, и Eclipse автоматически исправит опечатку или добавит оператор импорта или предоставит вам заглушку для метода, сохраняя множество ввода.

Читайте также:  За семью морями для андроид

Вы можете вручную скомпилировать свой код, если хотите. В Eclipse вы найдете настройки сборки в меню проекта. Если вы включили «Build Automatically», вы все равно можете выбрать опцию «Clean . », которая позволит вам полностью перестроить все файлы. Если «Build Automatically» отключено, включены опции «Build All» и «Build Project». «Build All» означает создание всех проектов в рабочей области. У вас может быть много проектов в рабочем пространстве Eclipse.

Процесс сборки для обычных проектов Java приводит к созданию файла с расширением JAR — Java ARchive. Приложения Android берут файлы JAR и упаковывают их для развертывания на устройствах как файлы Android PacKage с расширением .apk. Эти форматы включают не только ваш скомпилированный Java-код, но и любые другие ресурсы, такие как строки, изображения или звуковые файлы, которые требуется выполнить вашему приложению, а также файл манифеста приложения, AndroidManifest.xml. Файл манифеста Android является файлом, требуемым всеми приложениями Android, которые вы используете для определения сведений о конфигурации вашего приложения.

Что такое объектно-ориентированный язык программирования?

Отлично. Время для очень короткого и 20 000-футового просмотра объектно-ориентированного программирования (ООП). ООП — это стиль или техника программирования, которые основаны на определении структур данных, называемых объектами. Для тех, кто новичок в ООП, объект можно воспринимать так же, как пользовательский тип данных. Например, у вас может быть объект Dog, который представляет собой чертёж общей собаки, с именем, породой и полом. Затем вы можете создавать разные экземпляры объекта Dog для представления конкретных собак. Каждый объект Dog должен быть создан путем вызова его конструктора (метода, который имеет то же имя, что и сам объект, и может иметь или не иметь параметров для установки начальных значений). Например, следующие объекты Dog используют конструктор с тремя параметрами (имя, порода, пол):

Итак, где этот объект Dog определен? Ну, здесь нам нужно начать определение некоторых фундаментальных строительных блоков языка программирования Java. Класс предоставляет определение для объекта. Таким образом, есть класс Dog где-нибудь, определенный вами или в какой-то библиотеке где-нибудь. Вообще говоря, класс будет определен в собственном файле с именем файла, соответствующим имени класса (например, Dog.java). Существуют исключения из этого правила, такие как классы, определенные в других классах (когда класс объявляется внутри класса, он обычно определяется для использования в родительском классе только как вспомогательный класс и называется внутренним классом).

Если вы хотите ссылаться на объект из другого класса, вам нужно включить оператор импорта в начало вашего файла класса, так же, как вы бы использовали оператор #include на компилированном языке, таком как C.

Класс обычно описывает данные и поведение объекта. Поведение определяется с помощью методов класса. Метод является общим термином для подпрограммы на языке ООП. Многие общие классы объектов определены в библиотеках общих классов, таких как комплекты разработки программного обеспечения (SDK), тогда как другие определяются вами, разработчиком, в ваших собственных целях. Затем программное обеспечение создается с использованием и манипулированием экземплярами объектов по-разному.

Пожалуйста, поймите, что это очень обобщенное определение ООП. На эту тему написаны целые книги. На эту тему написаны целые книги. Википедия имеет хороший обзор ООП

Примечание. В этом уроке мы используем много разных терминов. Существует несколько способов ссылаться на данную концепцию (например, суперкласс по сравнению с родительским классом), что сбивает с толку тех, кто новичок в объектно-ориентированном программировании. Различные разработчики используют разные термины, и поэтому мы старались упоминать синонимы там, где это необходимо. Решение о том, какие условия вы будете использовать, является личным выбором.

Понимание наследования

Вот еще одна важная концепция Java, с которой вы столкнетесь: наследование. Проще говоря, наследование означает, что классы Java (и, следовательно, объекты) могут быть организованы в иерархии с более низкими, более конкретными классами в иерархии, наследующие поведение и черты из более высоких, более общих классов.

Эта концепция лучше всего иллюстрируется примером. Давайте притворимся, что мы разрабатываем Java-приложение для имитации аквариума. В этом аквариуме есть рыба. Поэтому мы могли бы определить класс для представления рыбы. Этот класс, называемый Fish, может включать в себя некоторые поля данных (также называемые атрибутами или переменными-членами класса) для описания объекта рыбы: вида, цвета и размера; а также некоторые его поведение в виде методов (также называемых подпрограммами или функциями в процедурных языках), таких как eat (), sleep () и makeBabyFish ().

Для создания и инициализации объекта используется специальный тип метода, называемый конструктором; конструкторы называются такими же, как и их класс, имогут включать в себя параметры. Следующий класс Fish имеет два конструктора: один для создания общего объекта Fish, а другой для конструирования определенного объекта Fish с некоторыми исходными данными. Вы также увидите, что у класса Fish есть два метода eat (): один для приема чего-то случайного, а другой — для еды другой рыбы, который будет представлен другим экземпляром класса Fish:

Классы могут быть организованы в иерархии, где производный класс (или подкласс) включает все функции его родительского класса (orsuperclass), но уточняет и добавляет к ним, чтобы определить более конкретный объект, используя ключевое слово extends. Это называется наследованием.

Например, класс Fish может иметь два подкласса: FreshwaterFish и SaltwaterFish. Эти подклассы будут иметь все функции класса Fish, но могут дополнительно настроить объекты с помощью новых атрибутов и поведения или модифицированного поведения из родительского класса Fish. Например, класс FreshwaterFish может включать информацию о типе пресноводной среды, в которой они жили (например, река, озеро, пруд или лужа). Аналогично, класс SaltwaterFish может настроить метод makeBabyFish() таким образом, чтобы рыба ест своего партнера после размножения (как определено в суперклассе), используя механизм переопределения, например:

Организация поведения объекта с интерфейсами

В Java вы можете организовать поведение объектов в так называемых интерфейсах. Хотя класс определяет объект, интерфейс определяет некоторое поведение, которое может быть применено к объекту. Например, мы можем определить интерфейс Swimmer, который предоставляет набор методов, которые являются общими для всех объектов, которые могут плавать, будь то рыба, выдры или погружные андроиды. Интерфейс Swimmer может указывать четыре метода: startSwimming(), stopSwimming(), dive() и surface().

Затем класс, подобный Fish, может реализовать интерфейс Swimmer (с использованием ключевого слова реализует) и обеспечить реализацию поведения плавания:

Организация классов и интерфейсов с пакетами

Затем иерархии классов, такие как наши классы рыбы, могут быть организованы в пакеты. Пакет — это просто набор классов и интерфейсов, объединенных вместе. Разработчики используют пространства имен для уникального имени пакетов. Например, мы могли бы использовать com.mamlambo.aquarium или om.ourclient.project.subproject в качестве нашего имени пакета, чтобы отслеживать наши классы, связанные с рыбой.

Заключение

Вау! Вы только что начали курс по сбору данных в Java для разработки Android. Мы рассмотрели здесь довольно много материала, поэтому давайте немного поразмыслим, прежде чем переходить к следующему уроку этой серии уроков. В уроке 2 мы переключим внимание на подробные детали синтаксиса Java.

Вы только поцарапали поверхность Java-разработки для разработки Android. Ознакомьтесь со всеми другими замечательными учебниками на Mobiletuts +, чтобы погрузиться глубже в разработку Java и Android. Удачи!

Источник

Оцените статью