I den här handledningen lär vi oss om Java Access Modifier, dess typer och hur man använder dem med hjälp av exempel.
Vad är åtkomstmodifierare?
I Java används åtkomstmodifierare för att ställa in tillgängligheten (synlighet) för klasser, gränssnitt, variabler, metoder, konstruktörer, datamedlemmar och settermetoderna. Till exempel,
class Animal ( public void method1() (… ) private void method2() (… ) )
I exemplet ovan har vi deklarerat två metoder: metod1 () och metod2 (). Här,
- metod1 är
public
- Detta betyder att den kan nås av andra klasser. - metod2 är
private
- Detta betyder att den inte kan nås av andra klasser.
Notera nyckelordet public
och private
. Dessa är åtkomstmodifierare i Java. De är också kända som synlighetsmodifierare.
Obs! Du kan inte ställa in åtkomstmodifieraren för getters-metoder.
Typer av åtkomstmodifierare
Innan du lär dig om typer av åtkomstmodifierare, se till att du känner till Java-paket.
Det finns fyra nyckelord för åtkomstmodifierare i Java och de är:
Modifierare | Beskrivning |
Standard | deklarationer är endast synliga i paketet (privat paket) |
Privat | deklarationer är endast synliga inom klassen |
Skyddade | deklarationer är synliga i paketet eller i alla underklasser |
offentlig | förklaringar är synliga överallt |
Standardåtkomstmodifierare
Om vi inte uttryckligen anger någon åtkomstmodifierare för klasser, metoder, variabler, etc, anses standardåtkomstmodifieraren som standard. Till exempel,
package defaultPackage; class Logger ( void message()( System.out.println("This is a message"); ) )
Här har Logger-klassen standardåtkomstmodifieraren. Och klassen är synlig för alla klasser som tillhör standardpaketpaketet. Men om vi försöker använda Logger-klassen i en annan klass utanför defaultPackage får vi ett kompileringsfel.
Privat åtkomstmodifierare
När variabler och metoder deklareras private
kan de inte nås utanför klassen. Till exempel,
class Data ( // private variable private String name; ) public class Main ( public static void main(String() main)( // create an object of Data Data d = new Data(); // access private variable and field from another class d.name = "Programiz"; ) )
I exemplet ovan har vi deklarerat en privat variabel med namnet och en privat metod med namnet display()
. När vi kör programmet får vi följande fel:
Main.java:18: error: name has private access in Data d.name = "Programiz"; ^
Felet genereras eftersom vi försöker komma åt den privata variabeln och den privata metoden för dataklassen från huvudklassen.
Du kanske undrar vad om vi behöver komma åt dessa privata variabler. I det här fallet kan vi använda metoden getters och setters. Till exempel,
class Data ( private String name; // getter method public String getName() ( return this.name; ) // setter method public void setName(String name) ( this.name= name; ) ) public class Main ( public static void main(String() main)( Data d = new Data(); // access the private variable using the getter and setter d.setName("Programiz"); System.out.println(d.getName()); ) )
Utgång :
Namnet är Programiz
I exemplet ovan har vi en privat variabel som heter namn. För att komma åt variabeln från den yttre klassen har vi använt metoder: getName()
och setName()
. Dessa metoder kallas getter och setter på Java.
Här har vi använt settermetoden ( setName()
) för att tilldela variabeln värde och gettermetoden ( getName()
) för att komma åt variabeln.
Vi har använt this
nyckelord inuti setName () för att hänvisa till klassens variabel. För att lära dig mer om detta nyckelord, besök Java detta nyckelord.
Obs! Vi kan inte förklara klasser och gränssnitt privata i Java. De kapslade klasserna kan dock förklaras privata. För att lära dig mer, besök Java Nested och Inner Class.
Skyddad åtkomstmodifierare
När metoder och datamedlemmar deklareras protected
kan vi komma åt dem inom samma paket och från underklasser. Till exempel,
class Animal ( // protected method protected void display() ( System.out.println("I am an animal"); ) ) class Dog extends Animal ( public static void main(String() args) ( // create an object of Dog class Dog dog = new Dog(); // access protected method dog.display(); ) )
Utgång :
Jag är ett djur
I exemplet ovan har vi en skyddad metod som heter display()
inom djurklassen. Djurklassen ärvs av hundklassen. Om du vill lära dig mer om arv besöker du Java Inheritance.
Vi skapade sedan en objekthund i hundklassen. Med hjälp av objektet försökte vi komma åt den skyddade metoden för föräldraklassen.
Eftersom skyddade metoder kan nås från barnklasserna har vi tillgång till metoden för djurklass från hundklassen.
Obs! Vi kan inte deklarera klasser eller gränssnitt protected
i Java.
Allmänhetsmodifierare
När metoder, variabler, klasser och så vidare deklareras public
kan vi komma åt dem var som helst. Den allmänna åtkomstmodifieraren har ingen begränsning av omfattningen. Till exempel,
// Animal.java file // public class public class Animal ( // public variable public int legCount; // public method public void display() ( System.out.println("I am an animal."); System.out.println("I have " + legCount + " legs."); ) ) // Main.java public class Main ( public static void main( String() args ) ( // accessing the public class Animal animal = new Animal(); // accessing the public variable animal.legCount = 4; // accessing the public method animal.display(); ) )
Utgång :
Jag är ett djur. Jag har fyra ben.
Här,
- Den offentliga klassen Djur nås från huvudklassen.
- Den offentliga variabeln legCount nås från huvudklassen.
- Den offentliga metoden
display()
nås från huvudklassen.
Åtkomstmodifierare Sammanfattat i en siffra

Åtkomstmodifierare används främst för inkapsling. Jag kan hjälpa oss att kontrollera vilken del av ett program som får tillgång till medlemmarna i en klass. Så att missbruk av data kan förhindras. För att lära dig mer om inkapsling, besök Java Encapsulation.