modificatore di accesso Scala

Scala e Java Access modificatori, come base, rispettivamente di: private, protected pubblico.

Se non si specifica un carattere modificatore di accesso, per impostazione predefinita, gli oggetti Scala livello di accesso sono pubbliche.

qualificatore Scala di accesso, di classe più rigorosi di Java, nel caso della classe annidata, classe esterna non può nemmeno essere annidato membri privati ​​privati.

membri (privati) Privato

Modificato con parola chiave privata, i membri con questo marchio contiene un'unica membro della classe o l'oggetto definito interna visibile, la stessa regola vale anche per le classi interne.

class Outer{
    class Inner{
    private def f(){println("f")}
    class InnerMost{
        f() // 正确
        }
    }
    (new Inner).f() //错误
}

(New interno) .F () l'accesso non è legale in interno perché f è dichiarato come privato, ma l'accesso non è all'interno della categoria di interni.

L'accesso f ma non c'è nessun problema nel più intimo, perché questa visita è inclusa nella classe interna.

Java è consentito l'accesso ad entrambi, perché permette l'accesso di classe membri privati ​​esterni delle classi interne.

Protezione (protetto) membri

Nella scala, la protezione di accesso (protetto) i membri sono più rigorose di java. Perché permette solo la protezione dei membri della sottoclasse è definito nella membro della classe si accede. In Java, utilizzare la parola chiave membri modificati protette, in aggiunta alla definizione di una sottoclasse della classe in grado di accedere al membro, con un pacchetto di altre classi si può accedere anche.

package p{
class Super{
    protected def f() {println("f")}
    }
	class Sub extends Super{
	    f()
	}
	class Other{
		(new Super).f() //错误
	}
}

L'esempio di cui sopra, Sub-tipo di accesso non è un problema per la f, f, perché è dichiarato come protetto nel Super e Super Sub è una sottoclasse. Al contrario, altri non è consentito l'accesso alla F, perché non c'è nessun altro ereditato dal Super. Mentre quest'ultimo anche essere riconosciuto in Java, perché con altri sotto nella stessa borsa.

Pubbliche (pubblico) membri

Scala, se non si specifica alcun modificatore, il valore predefinito è pubblico. Tale membro può accedere ovunque.

class Outer {
   class Inner {
      def f() { println("f") }
      class InnerMost {
         f() // 正确
      }
   }
   (new Inner).f() // 正确因为 f() 是 public
}

L'ambito di tutela

Scala, il modificatore di accesso può essere sottolineato utilizzando qualificazioni. Il formato è:

private[x] 

或 

protected[x]

Dove x si riferisce a un pacchetto appartiene a una classe o di un oggetto Singleton. Se scritto in privato [x], leggere "Oltre ai membri della [...] o nella classe [...] delle classi in pacchetti e la loro immagine associata visibili sulla parte esterna, per tutte le altre classi sono privati.

Questa tecnica è utile in un certo numero di grandi progetti nel pacchetto, che consente di definire diversi sub-package nel progetto clienti esterni visibili, ma il progetto ha sempre le cose invisibili.

package bobsrocckets{
    package navigation{
        private[bobsrockets] class Navigator{
         protected[navigation] def useStarChart(){}
         class LegOfJourney{
             private[Navigator] val distance = 100
             }
            private[this] var speed = 200
            }
        }
        package launch{
        import navigation._
        object Vehicle{
        private[launch] val guide = new Navigator
        }
    }
}

L'esempio di cui sopra, il Navigatore classe è contrassegnato come privato [bobsrockets] Questa è la classe di tutte le classi e gli oggetti contenuti nel pacchetto bobsrockets visibile.

Ad esempio, dall'accesso Veicolo all'oggetto nel Navigator è consentito in quanto il veicolo oggetto incluso nel pacchetto lancio, mentre in bobsrockets lanciare pacchetto, al contrario, tutto il codice di fuori delle bobsrockets pacchetto può accedere classe Navigator.