Tilgangsmodifiserere i java

Access Modifier er en objektorientert terminologi som brukes til å definere tilgjengeligheten til klasser, metoder og konstruktører. Å være objektorientert programmering, støtter Java fire forskjellige nivåer av tilgangsmodifiserere, og hver tilgangsmodifiserer fungerer på et annet nivå. Tilgangsmodifikatorene kan være ett av følgende, standard, offentlige, private og beskyttede. Valg av tilgangsmodifiserer avhenger av problemet du skal løse. Denne beskrivende guiden demonstrerer funksjonaliteten til tilgangsmodifiserere i Java.

Tilgangsmodifiserere i java

Denne delen gir en dyp innsikt i tilgangsmodifiserere i Java. Du vil få en detaljert beskrivelse av hver modifiserer demonstrert av et eksempel som illustrerer funksjonaliteten til hver tilgangsmodifiserer.

Offentlig tilgangsmodifiserer

Som navnet på modifisereren antyder, er den minst sikker og klasser, metoder, forekomster erklært ved bruk av offentlige nøkkelord har følgende tilgjengelighetsalternativer:

- De kan nås i pakken/klassen, utenfor pakken/klassen

Eksempel

pakke newpack;
Offentlig klasse AccessMod

public void show ()

System.ute.Println ("Velkommen til Linuxhint!");

Koden skrevet ovenfor har følgende beskrivelse:

- En offentlig klasse og en offentlig metode er erklært som inneholder en uttalelse om utskriftslinje.

Bildet av koden er gitt her:

Klassemetoden som heter forestilling I ovennevnte kode kalles i andre klasse som vist nedenfor:

pakke mod;
Importer Newpack.*;
Klassetilgangm
public static void main (String args [])

AccessMod obj = new AccessMod ();
obj.forestilling();

Koden er beskrevet nedenfor

- pakketavnet Newpack av klassen importeres

- et objekt i klassen AccessMod (Klasse som er bosatt i pakken som heter Newpack) er skapt

Bildet av koden og utgangen vises nedenfor:

Fra opsjonen ovenfor konkluderes det med at modifiseringsmodifiserere av offentlig tilgang kan få tilgang til gjenstandene i en klasse som også er utenfor den klassen og pakken.

Privat tilgangsmodifiserer

I motsetning til den offentlige klassen, kan private metoder/Varibales bare nås inne i klassen. En private metoder/variabler kan ikke nås:

- utenfor pakken

- innenfor pakken (men ut av klassen)

Eksempel 1: Utenfor pakken

pakke newpack;
Klasse AccessMod

Privat Void Show ()

System.ute.Println ("Linuxhint!");

Beskrivelsen av koden er gitt nedenfor:

- Show -metoden er erklært med en privat modifiserer

Nå prøver følgende kode å utføre showmetoden fra AccessMod klasse.

pakke mod;
Importer Newpack.*;
Klassetilgangm
public static void main (String Argos [])

AccessMod obj = new AccessMod ();
obj.forestilling();

En ny klasse som heter Accesm er opprettet i MOD -pakken. De Newpack Pakken importeres i denne pakken, da vi må opprette et objekt i klassen som er navngitt AccessMod (som ligger i Newpack's klasse).

Det fremgår av utgangen at AccessMod og de tilhørende objektene ikke kunne nås utenfor pakken.

Eksempel: Utenfor klassen (samme pakke)

pakke LH;
klasse prim
privat tomrom pvt ()
System.ute.Println ("Linuxhint");

Koden er beskrevet som,

- en klasse som heter prim er opprettet i LH pakke. De prim Klassen inneholder en privat metode som heter Pvt.

Nå, for å bekrefte den private tilgangsmodifisereren, brukes koden nedenfor.

pakke LH;
Klasse sekund
public static void main (String [] main)
prim obj = ny prim ();
obj.pvt ();

Pakken med begge klassene er den samme, men klassen som heter Second prøver å lage et objekt av PVT (). Pvt () er en metode i prim klasse.

Det observeres fra utgangen at, pvt () Metode kan ikke nås på grunn av sin private tilgangsmodifiserer.

Standard tilgangsmodifiserer

Datamedlemmene erklært ved hjelp av standard nøkkelord er bare tilgjengelige innenfor samme pakke. Det faller mellom private og beskyttede tilgangsmodifiserere, og dermed er den sikrere enn beskyttet og minst sikker enn privat.

Eksempel 1: Utenfor pakken

pakke newpack;
klasse def
statisk tomrom Main (String [] args)
System.ute.println ("en standardklasse");

Beskrivelsen av koden er som følger,

- Det opprettes en standardklasse Def og den inneholder hovedmetoden

- En utskriftslinjeuttalelse utføres i hovedmetoden

For å teste tilgjengeligheten til standardklassen, brukes følgende kodelinjer.

pakke LH;
Importer Newpack.*;
klasse Deft
statisk tomrom Main (String [] args)
Def test = new def ();
test.hoved();

Koden er beskrevet som,

- importerte pakken som heter Newpack

- opprettet en ny klasse Deft

- opprettet et objekt i klassen Def I hovedmetoden til Deft klasse

Utgangen viser at tilgjengeligheten til Def Klasse må endres til publikum for å få tilgang til i en klasse av andre pakker.

Eksempel 2: utenfor klassen (innenfor samme pakke)

Følgende kode oppretter en standardmetode for en kalt klasse prim.

pakke LH;
klasse prim
void pub ()
System.ute.Println ("Standard Access Modifier");

En standardmetode som heter pub() er definert i klassen prim.

La oss se på følgende kode for å bekrefte tilgjengeligheten.

pakke LH;
Klasse sekund
public static void main (String [] main)
prim obj = ny prim ();
obj.pub();

Et objekt av pub() Metoden opprettes i en annen klasse (som ligger i samme pakke).

Det observeres fra utgangen at objektet til pub() Metoden utføres vellykket, og dermed konkluderes det med at metodene erklæres ved hjelp av standard tilgangsmodifiserere kan brukes i samme pakke, men i forskjellige klasse.

Beskyttet tilgangsmodifiserer

Metodene eller datamedlemmene som er erklært ved hjelp av beskyttede nøkkelord er tilgjengelige i klassen eller de andre klassene i samme pakke. Det kan ikke nås utenfor pakken, men en underklasse av de andre pakkene kan få tilgang til de beskyttede metodene.

Eksempel: Bruke underklasse av samme pakke

pakke newpack;
Klasse AccessMod

beskyttet tomrom show ()

System.ute.Println ("Linuxhint!");

Show () -metoden erklært med beskyttede privilegier:

Metoden er tilgjengelig i Accessm (underklasse av den samme pakken der AccessMod løgner) og prosessen utføres ved hjelp av følgende kode:

pakke newpack;
Class AccessM utvider AccessMod
public static void main (String args [])

AccessMod obj = new AccessMod ();
obj.forestilling();

Utgangsbildet av koden er gitt nedenfor:

La oss nå utdype forskjellen mellom standard og beskyttet tilgangsmodifiserere ved å bruke følgende eksempel. Standard tilgangsmodifiserere kan ikke nås av underklasser (utenfor pakken), men vi får tilgang til en beskyttet metode ved å bruke en underklasse.

Eksempel 2: Bruke underklasse av andre pakker

pakke LH;
offentlig klasse prot
beskyttet tomromsdisplay ()
System.ute.Println ("Velkommen til Linuxhint!");

I koden ovenfor er en beskyttet metode erklært i en klasse som inneholder en enkel uttalelse om utskriftslinje.

Koden skrevet nedenfor vil opprette og få tilgang til objektet med den beskyttede metoden som vises i bildet ovenfor.

pakke newpack;
Importer LH.*;
Klasseprotmod utvider prot
public static void main (String args [])

ProtMod obj = new ProtMod ();
obj.vise();

Du vil observere det,

- pakken LH importeres til pakken Newpack

- en underklasse (av Prot klasse) navngitt Protmod er erklært

- objekt med protmod -klassen som heter obj brukes til å få innholdet i vise() Metode av Prot klasse).

Utgangen viser at vise() metode inneholdt inne i Prot klasse brukes i underklassen til Prot klasse.

Konklusjon

Javas tilgangsmodifiserere lar deg bestemme tilgjengelighetsnivået på metoder, klasser, variabler og konstruktører. Denne artikkelen gir funksjonaliteten til tilgangsmodifisererne som kan brukes i Java. Tilgangsmodifiserene som private, offentlige, beskyttede og standard utøves ved hjelp av forskjellige eksempler. Til slutt konkluderes det med at de private modifikatorene setter den sikreste plattformen, mens de offentlige modifikatorene regnes som de minst sikre.