Java 8 pre Android rozvoj: predvolené a statické metódy

Slovak (Slovenčina) translation by Tereza Foretová (you can also view the original English article)

Java 8 bol obrovský krok vpred pre programovací jazyk a teraz s vydaním Android Studio 3.0 Android vývojári konečne mať prístup k vstavaný podporu pre niektoré Java 8 je najdôležitejšie funkcie.

V tejto trojdielny série, sme začali skúmať Java 8 funkcií, môžete začať používať svoj Android projekty dnes. V čistejší kód s Lambda výrazy, budeme nastaviť náš vývoj používať Java 8 podpora poskytovaná Android je predvolené toolchain, pred užitím Podrobný pohľad lambda výrazy.

V tento post sa pozrieme na dva rôzne spôsoby, že môžete vyhlásiť-abstraktné metód v rozhrania (niečo, čo nebolo možné v starších verziách programu Java). Sme si tiež odpovedať na otázku, teraz, že rozhrania môžete implementovať metódy, čo presne je rozdiel medzi abstraktné triedy a rozhrania?

Budeme tiež vzťahujúca Java 8 funkcia, ktorá vám dáva slobodu používať rovnaký komentár toľkokrát, koľkokrát budete chcieť na rovnakom mieste, zatiaľ čo zostávajúce spätne kompatibilný so staršími verziami Androidu.

Ale prvé, poďme sa pozrieť na Java 8 funkcia, ktorá je určená na použitie v kombinácii s lambda výrazy, ktoré sme videli v predchádzajúcej post.

Napísať čistič Lambda výrazy, metóda Odkazy

V posledný príspevok, videl si, ako môžete použiť lambda výrazy odstrániť veľa štandardný kód z vášho Android aplikácií. Však keď výraz lambda je jednoducho zavolaním jedinú metódu, ktorá už má meno, ešte viac kód môžete znížiť z projektu s použitím referenčnej metódy.

Napríklad, tento výraz lambda je naozaj len presmerovanie práce na existujúcu metódu handleViewClick:

  FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
  fab.setOnClickListener(view -> handleViewClick(view));
}

private void handleViewClick(View view) {

}

V takomto prípade budeme označovať Táto metóda názov pomocou:: metóda referenčného subjektu. Môžete vytvoriť tento druh metóda odkaz v nasledujúcom formáte:

Object/Class/Type::methodName

V na‰om plávajúce tlačidlo akcie môžeme použiť referenčné metódy ako telo nášho lambda expression:

  FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
  fab.setOnClickListener(this::handleViewClick);
}

Všimnite si, že metódu odkazovaný musí mať rovnaké parametre ako rozhranie – v tomto prípade to je názor.

Metóda referenčného subjektu (:) môžete použiť odkaz na niektorý z nasledujúcich krokov:

Statická metóda

Ak máte lambda expression, ktorá vyzýva statická metóda:

(args) -> Class.staticMethod(args)

Potom môžete zahnúť do referenčnej metódy:

Class::staticMethodName

Napríklad, ak máte statickú metódu PrintMessage v class Moja_trieda, potom referenčné metódy by vyzerať nejako takto:

public class myClass {  
   public static void PrintMessage(){  
       System.out.println("This is a static method");  
   }  

}  
   public static void main(String[] args) {  
       Thread thread = new Thread(myClass::PrintMessage);  
       thread.start();       
   }  
}

Stupňa metódy špecifického predmetu

Toto je metóda inštanciu objektu, ktorá je známa vopred, čo umožňuje nahradiť:

(arguments) -> containingObject.instanceMethodName(arguments)

containingObject::instanceMethodName

Takže, ak ste mal nasledujúci výraz lambda:

MyClass.printNames(names, x -> System.out.println(x));

Potom Predstavujeme referenčná metóda by vám takto:

MyClass.printNames(names,System.out::println);

Stupňa metódy objektu ľubovoľného určitého typu

Toto je metóda stupňa ľubovoľného objektu, ktorý bude dodaný neskôr, a napísaný v nasledovnom formáte:

ContainingType::methodName

Konštruktér Odkazy

Konštruktér odkazy sú podobná metóda referencií, okrem toho, že používate kľúčové slovo nové vyvolať konštruktéra. Napríklad Button::new je odkaz konštruktor pre triedu tlačidlo, Hoci presný konštruktor, ktorý je vyvolaný závisí od kontextu.

Používanie konštruktéra odkazov, sa môžete obrátiť:

(arguments) -> new ClassName(arguments)

Do:

ClassName::new

Napríklad, ak ste mali MyInterface rozhranie:

  public Interface myInterface{
  public abstract Student getStudent(String name, Integer age);
}

Potom môžete využiť referencie konštruktéra vytvoriť nové inštancie študent:

myInterface stu1 = Student::new;
Student stu = stu1.getStudent("John Doe", 27);

Je tiež možné vytvoriť konštruktor Odkazy pre pole typov. Konštruktér odkaz pre rad azuje je napríklad [int]:: nové.

Pridať predvolené metódy rozhrania

Pred Java 8, by mohol obsahovať len abstraktné metód v rozhrania (t. j. metódy bez karosérie), ktoré bolo ťažké vyvinúť rozhrania, po uverejnení.

Zakaždým, keď ste pridali metóda pre definíciu rozhrania, tried, ktoré implementované rozhrania by zrazu chýba implementácia. Napríklad keby rozhranie (MyInterface), ktorý bol používaný Moja_trieda pridaním metóda do MyInterface zlomí kompatibilitu s Moja_trieda.

V najlepšom prípade scenár, kde ste boli zodpovední za malý počet tried, ktoré používajú MyInterface, toto správanie by bolo nepríjemné, ale zvládnuteľné — len budete musieť vyčleniť nejaký čas na aktualizáciu svojich tried novej implementácii. Však čo by sa mohlo stať oveľa zložitejšie, ak veľký počet tried implementované MyInterface alebo rozhranie bol použitý v triedach, ktoré ste neboli zodpovední za.

Kým tam boli rad riešenia tohto problému, žiadny z nich boli ideálne. Napríklad by mohli zahŕňať nových metód v abstraktná trieda, ale by to stále vyžadujú všetci aktualizovať ich kód rozšíriť tento abstraktná trieda; a zatiaľ čo mohol rozšíriť pôvodný rozhranie s novým rozhraním, kto chcel využiť týchto nových metód by potom potrebné prepísať všetky existujúce odkazy rozhranie.

So zavedením predvolené metódy v jazyku Java 8, je teraz možné deklarovať-abstraktné metódy (t. j. metódy s telom) vnútri rozhrania, takže si môžete konečne vytvoriť predvolený implementácie pre vaše metódy.

Keď pridáte metódu rozhrania ako predvolenej metódy, trieda, ktorá implementuje toto rozhranie nemusia nevyhnutne poskytnúť plnenie, ktoré poskytuje spôsob aktualizácie rozhrania bez porušenia kompatibility. Ak pridáte novú metódu na rozhranie ako predvolený spôsob, v každej triede, ktorý používa toto rozhranie, ale neposkytuje svojej vlastnej implementácii bude jednoducho dediť metóda predvolenej implementácie. Vzhľadom k tomu, trieda nie je chýba implementácia, budem naďalej fungovať ako normálne.

V skutočnosti, zavedenie predvolené metódy bolo dôvodom, že Oracle bol schopný robiť takéto veľké množstvo dodatkov kolekcie API v Jave 8.

Kolekcia je Generické rozhranie, ktoré sa používa v mnohých rôznych tried, takže pridávať nové metódy tohto rozhrania mal potenciál prelomiť nespočetné množstvo riadkov kódu. Namiesto pridania nových metód zberu rozhranie a lámanie každej triede, ktorá bola odvodená z tohto rozhrania, Oracle vytvoril funkciu predvolenú metódu a potom pridáva tieto nové spôsoby ako predvolené metódy. Ak ste sa pozrieť na nové Collection.Stream() metóda, (ktorý budeme skúmať podrobne v časti tri), uvidíte, že to bol pridaný ako predvolený spôsob:

 default Stream<E> stream() {
     return StreamSupport.stream(spliterator(), false);
   }

Vytvorenie predvolenej metódy je jednoduchá – stačí pridať modifikátor predvolený podpis metódy:

public interface MyInterface {
  void interfaceMethod();
  default void defaultMethod(){
      Log.i(TAG,"This is a default method”);
  }
}

Teraz, ak Moja_trieda používa MyInterface, ale neposkytuje svojej vlastnej implementácii defaultMethod, budem len dediť predvolenej implementácie poskytovaný MyInterface. Napríklad, stále bude zostavovať nasledujúce triedy:

public class MyClass extends AppCompatActivity implements MyInterface {
}

Vykonávacie triedy môžete prepísať predvolenej implementácie poskytuje rozhranie, takže triedy sú stále v úplnú kontrolu nad ich implementácie.

Predvolené metódy sú vítaným prírastkom pre API dizajnérov, môže občas spôsobiť problém pre vývojárov, ktorí sa snažia používať viacero rozhraní v rovnakej triede.

Predstavte si, že okrem MyInterface, máte nasledujúce:

public interface SecondInterface {
  void interfaceMethod();
  default void defaultMethod(){
      Log.i(TAG,"This is also a default method”);
  }
}

MyInterface a SecondInterface obsahovať predvolenú metódu s presne rovnakým podpisom (defaultMethod). Teraz si predstavte, môžete skúsiť použiť oba tieto rozhrania v tej istej triede:

public class MyClass extends AppCompatActivity implements MyInterface, SecondInterface {
}

Na tomto mieste máte dva protichodné implementácie defaultMethod a kompilátor nemá tušenie spôsob, ktorý by mali používať, takže budete stretnete chybu kompilátor.

Jeden spôsob, ako vyriešiť tento problém je prepísať metódu protichodné s vlastné vykonávanie:

public class MyClass extends AppCompatActivity implements MyInterface, SecondInterface  {
  public void defaultMethod(){
       
  }
}

Ďalším riešením je určiť, ktorá verzia defaultMethod chcete vykonať, použite nasledovný formát:

<interface name>.super.<method name>();

Takže ak ste chceli volať MyInterface#defaultMethod() Implementácia, potom by použiť nasledovné:

public class MyClass extends AppCompatActivity implements MyInterface, SecondInterface {
   public void defaultMethod(){
     MyInterface.super.defaultMethod();
    }
}

Pomocou statickej metódy v rozhraní Java 8

Podobne ako predvolené metódy, metódy statické rozhranie vám spôsob, ako definovať metódy vo vnútri rozhranie. Však na rozdiel od predvolenej metódy, vykonávacie triedy sa nedá prepísať rozhranie statickej metódy.

Ak máte statickej metódy, ktoré sú špecifické pre rozhranie, potom Java 8 statických rozhranie metódy vám spôsob uvádzania týchto metód vnútri príslušné rozhranie, skôr ako musieť ukladať ich do samostatnej triedy.

Môžete vytvoriť statickú metódu tým, že kľúčové slovo statické začiatku podpis metódy, napríklad:

public interface MyInterface {
   static void staticMethod(){
      System.out.println("This is a static method");
  }   
}

Kedy ste implementovať rozhranie, ktoré obsahuje statické rozhranie metódy, statická metóda je stále súčasťou rozhrania a nie je dedí triedu vykonáva, takže budete musieť predpony s metódou názov rozhrania, napríklad:

public class MyClass extends AppCompatActivity implements MyInterface {
    public static void main(String[] args) {
        MyInterface.staticMethod();
...
...
...

To tiež znamená, že trieda a rozhranie môžu mať statickú metódu s rovnakým podpisom. Napríklad pomocou MyClass.staticMethod a MyInterface.staticMethod v rovnakej triede nespôsobí chybu kompilácie.

Takže sú v podstate len abstraktné triedy rozhraní?

Pridanie statického rozhranie a predvolené metódy viedlo niektorých vývojárov k otázke, či Java rozhrania sú čoraz viac ako abstraktné triedy. Aj s prídavkom predvolené a statické rozhranie metódy, existujú však stále niektoré pozoruhodné rozdiely medzi rozhraniami a abstraktné triedy:

Abstraktné triedy môžu mať konečné, non-konečné, statické a non-static premenné, keďže rozhranie môžete mať len statickú a konečnú premenných.
Abstraktné triedy umožňujú vyhlásiť polia, ktoré nemajú statickú a konečnú, keďže rozhranie polia sú vo svojej podstate statickú a konečnú.
V rozhraní, všetky metódy, ktoré vyhlásiť alebo určiť ako predvolené metódy sú neodmysliteľne verejný, zatiaľ čo v abstraktné triedy môžete definovať verejné, chránené a súkromné konkrétnych metód.
Abstraktné triedy sú triedy, a preto môže mať štát; rozhrania nemôže mať stavu spojené s nimi.
Môžete definovať konštruktérov vnútri abstraktná trieda, niečo, čo nie je možné vo vnútri rozhrania Java.
Java umožňuje len rozšíriť jednu triedu (bez ohľadu na to, či je abstraktné), ale máte možnosť realizovať toľko rozhrania, ako budete požadovať. To znamená, že rozhrania majú zvyčajne okraj keď požadujete viacnásobnú dedičnosť, aj keď treba pozor na smrtiace diamond smrť!

Vzťahujú rovnaké poznámky toľkokrát, koľkokrát chcete

Tradične, jeden z obmedzenia Java poznámky bolo, že nemôžete použiť rovnakú poznámku viac než raz v rovnakom umiestnení. Skúste použiť rovnakú komentár niekoľkokrát, a ste sa stretli s chybami kompilácie.

Však so zavedením Java 8 opakujúcich sa anotácie, teraz ste voľne používať rovnaký komentár toľkokrát, koľkokrát chcete, na rovnakom mieste.

S cieľom zabezpečiť váš kód je stále kompatibilný so staršími verziami programu Java, budete musieť uložiť opakovanie poznámky v anotáciu kontajnera.

Môžete povedať kompilátor generovať tento kontajner, vykonaním nasledujúcich krokov:

Značka komentára s @Repeatable meta-poznámky (komentára, ktorá slúži k anotácii poznámky). Napríklad, ak ste chcel, aby @ToDo Anotácia opakovateľné, by použiť: @Repeatable(ToDos.class). Hodnota v zátvorke je typ kontajnera komentára, ktorý nakoniec prinesie kompilátor.
Vyhlásenie obsahujúce typ komentára. To musí mať atribút, ktorý je rad opakujúcich sa typ komentára, napríklad:

public @interface ToDos {
   ToDo[] value();
}

Pokúšam sa uplatňujú rovnaké poznámky viackrát, bez najprv vyhlasuje, že je opakovateľné bude mať za následok chybu pri kompilácii. Však keď ste už určili, že je opakovateľné komentára, môžete použiť tento komentár viackrát v akomkoľvek mieste, kde používate štandardný komentára.

Záver

V tejto druhej časti nášho seriálu o Java 8 sme videli, ako si môžete znížiť ešte viac štandardný kód z vášho Android projekty kombináciou lambda výrazy odkazmi metóda a ako posilniť svoje rozhrania s predvolené a statické metódy.

V tretej a poslednej splátky, sa pozrieme na nové 8 Java API, ktoré umožňuje proces obrovské množstvo údajov efektívnejšie, deklaratívne spôsobom, bez nutnosti starať o riadení súbežnosť a vlákno. Sme budete tiež byť previazanie niekoľko rôznych funkcií, ktoré sme diskutovali v tejto sérii, skúmaním úlohu, že funkčné rozhrania musieť hrať lambda výrazy, statické rozhranie metódy, štandardné metódy a ďalšie.

A napokon, hoci stále čakáme na Java 8 je nový dátum a čas API oficiálne dorazí na Android, ukážem, ako môžete začať používať toto nové API do vášho Android projektov dnes s pomocou niektorých knižníc tretích strán.

Do tej doby, pozrite sa na niektoré naše ďalšie príspevky o vývoj aplikácií Java a Android!