Láthatóság-módosítók Kotlinban

1. Bemutatkozás

A Kotlin programozási nyelv a Java virtuális gépre (JVM) épül. Mint ilyen, be kell tartania a JVM által előírt összes szabályt - beleértve a láthatóság módosítóit is.

Van azonban néhány finom árnyalat abban, hogy a nyelv hogyan hajtja végre ezeket a módosítókat a fordítóval és a kódunk felépítésével kapcsolatban. Ez a cikk bemutatja a Java és Kotlin közötti hasonlóságokat és különbségeket e tekintetben.

2. Láthatóság-módosítók

A láthatóság-módosítók segítségével meghatározható, hogy a kód mely elemei férjenek hozzá a módosítandó elemhez. A kód néhány különböző elemére vonatkoznak, a hatókör különböző szintjein. E szabályok alkalmazásának módja kissé eltérhet a különböző felhasználási módok között, ami elsőre zavaró lehet.

2.1. Nyilvános láthatóság

A legnyilvánvalóbb módosító az nyilvános. Ez valószínűleg a leggyakrabban használt az egész nyelven, és azt jelenti, hogy nincsenek további korlátozások arra vonatkozóan, hogy ki láthatja az elem módosítását.

A Java-val ellentétben Kotlinban szinte soha nincs szükség semmire nyilvánosnak nyilvánításra - ez az alapértelmezett módosító, amelyet akkor használunk, ha nem deklarálunk másikat. Ettől eltekintve ugyanúgy működik Kotlinban, mint Java-ban.

Ha alkalmazzuk a nyilvános egy felső szintű elem módosítója - egy külső osztály vagy egy csomagban közvetlenül deklarált függvény vagy változó -, akkor bármely más kód hozzáférhet hozzá. Ha alkalmazzuk a nyilvános beágyazott elem - egy belső osztály, vagy egy osztályon belüli függvény vagy változó - módosítója, akkor minden olyan kód, amely hozzáférhet a tárolóhoz, szintén hozzáférhet ehhez az elemhez.

Például:

osztály Nyilvános {val i = 1 fun doSomething () {}} 

Osztály Nyilvános elérhető a teljes kódbázis bárhonnan, „Val i ”és„ szórakozás csinálj valamit()" bárhonnan elérhetőek, amelyhez hozzáférhet Nyilvános.

2.2. Privát láthatóság

A másik módosító, amelyet az idő nagy részében használnak, az magán. Ennek szinte teljesen ellentétes jelentése van nyilvános - azt jelenti, hogy senki sem férhet hozzá.

A valóságban, Kotlinban ez azt jelenti, hogy csak az azonos hatókörön belül deklarált kód férhet hozzá. Ez finoman különbözik a Java-tól pusztán azért, mert Kotlin több felső szintű deklarációt tesz lehetővé ugyanabban a fájlban - a magán a legfelső szintű elemhez minden más hozzáférhet ugyanabban a fájlban. Ettől eltekintve a szabályok ugyanazok. Például:

Például:

privát osztály Privát {private val i = 1 private val doSomething () {}}

Osztály Magán csak ugyanazon forrásfájlból érhető el, „Val i ”és„ szórakozás csinálj valamit()" csak az osztály belsejéből érhetők el Magán.

2.3. Védett láthatóság

A oelfordítva a Kotlinban található módosító azt jelenti, hogy szigorúan csak a deklaráló osztály és az alosztályok által érhető el. Ez ugyanaz, mint a legtöbb ember elvárja, hogy a Java működjön, de finoman eltér a Java működésétől.

Java-ban az védett A módosító lehetővé teszi az elemhez való hozzáférést bárhonnan, ugyanabban a csomagban. Például a következő osztályfájlt adva:

A osztály {védett val i = 1}

A következő fájl jól működik Kotlinban:

B osztály: A () {fun getValue (): Int {return i}}

A következő fájl Java-ban működik, de Kotlin-ban nem fog működni:

C osztály {fun getValue (): Int {val a = A () return a.i}}

És a következők nem működnek sem Java-ban, sem Kotlinban:

D osztály {fun getValue (): Int {val a = A () return a.i}}

Ezenkívül Kotlinban védett az alapértelmezett láthatóság lesz, amikor felülírunk egy védett elem egy szuperosztályból. Ez kifejezetten megváltoztatható nyilvános ha szükséges, és ez a fő idő, akkor nyilvánosan nyilvánosságra kell hoznunk valamit.

2.4. Package-Private / Default Visibility

A Java-ban van egy „csomag-privát” néven ismert hozzáférés-módosító (más néven “alapértelmezett”). Ezt akkor használják, ha nincs módosító elhelyezve az elemen. Ez azt jelenti, hogy ugyanabban a csomagban bármelyik kód elérheti, de egy másik csomagban lévő bármely kód nem, beleértve az alosztályokat is.

Kotlin jelenleg egyáltalán nem támogatja ezt a módosítót, bár ez a jövőben változhat. Ennek az az oka, hogy nem nyújt védelmet - bárki megadhat kódot ugyanabban a csomagban, és hozzáférhet az elemeinkhez, akár egy másik jar fájlból is.

2.5. Belső láthatóság

Kotlin új módosítót ad hozzá azokhoz az opciókhoz, amelyeket a Java jelenleg nem támogat - belső. Ez a módosító azt jelenti, hogy az ugyanabban a modulban deklarált bármely kód, amely egyébként nincs korlátozva, hozzáférhet ehhez az elemhez. (A modul lényegében egy Jar fájl.)

Ez Java-ban lehetséges, például OSGi használatával, de jelenleg nem őshonos a nyelvben. A Java 9 néhány olyan fogalmat hoz létre, amelyek elérhetőbbé teszik azáltal, hogy szelektíven képesek exportálni a nyilvános azonosítókat.

Ez óriási előnyt jelent az API-k és a megvalósítások írásakor. Írhatjuk az API-felületeinket nyilvános, fő megvalósításunk as nyilvános osztályok és az összes támogatási kód, amelytől függ belső. Ez azt jelenti, hogy a külső kód kénytelen átmenni az API-n, és nem férhet hozzá a belső egységekhez. Például:

csomag com.baeldung.modifiers belső osztály Belső {} osztály Nyilvános {belső val i = 1 belső szórakozás doSomething () {}}

Osztály Belső csak ugyanazon modul belsejéből érhető el. „Val i” és „Fun doSomething ()” szintén csak ugyanazon modul belsejéből érhetők el, bár az osztály, amelyben vannak, bárhonnan elérhető.

3. Összefoglalás

A cikkben áttekintettük Kotlin láthatósági módosítóit.

A Kotlin láthatóság-módosító szabályai legtöbbször ugyanúgy működnek, mint amit a Java-tól elvárunk. Van azonban egy nagy különbség - ami a belső hatókör - ami nagyon hasznos nagyobb projekteknél.