Introduktion om inkapsling i Java
Inkapsling är ett av de fyra grundläggande objektorienterade programmeringskoncepten i Java. Huvudtanken bakom detta är att dölja implementeringsdetaljer från användare. Med andra ord är kapsling inpackning av data i en enda enhet för att förhindra åtkomst till den från omvärlden. Eftersom uppgifterna är dolda från de andra klasserna, är denna process också känd som Data-dölja. Låt oss betrakta hur en glödlampa fungerar som ett exempel. Vi vet inte det faktiska arbetet bakom glödlampan, även om vi använder den. Men i fallet med Java Encapsulation är det möjligt att komma åt data med hjälp av modifierare. Låt oss undersöka det i nästa avsnitt.
Hur fungerar Encapsulation i java?
Inkapsling fungerar i Java av
- Att deklarera attribut eller variabler i klassen som privat
Till exempel skapar vi en klass anställd. Variablerna måste ställas in som privata som visas nedan.
private String EmpName;
private int EmpID;
private int EmpSal;
- Skapa offentliga metoder i klassen för att få och ställa in attribut eller variabler.
Följande är get-metoden och uppsättningsmetoden för de olika privata variablerna i klassen anställd.
Koda:
public int getEmpSal()
(
return EmpSal;
)public String getEmpName()
(
return EmpName;
)
public int getEmpID()
(
return EmpID;
)
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
Med hjälp av dessa metoder är det möjligt att göra klassen skrivskyddad eller skrivskyddad, dvs. vi kan hoppa över dessa metoder om det behövs.
Följande är några av fördelarna med inkapsling.
- Enkelhet i tillämpningen
- Möjlighet att återanvända eller ändra koden baserat på kraven
- Begränsar tillgängligheten för data
- Enkelhet i enhetstestning när koden är inkapslad
Java Bean Class är ett av exemplen för den helt inkapslade klassen eftersom alla datamedlemmar i klassen är privata.
Exempel på Java-inkapsling
Låt oss se ett exempel på inkapsling med både getter- och settermetoder. För att skapa 2 klasser-en med huvudmetod och andra med att få och ställa in metoder.
Exempel 1
- Employee.java
Koda:
//Java program for Encapsulation with both read and write
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(
return EmpSal;
)
// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
)
- EmployeeEncaps.java
Koda:public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Anna");
EmpObj.setEmpSal(30000);
EmpObj.setEmpID(670311);
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Produktion:
I ovanstående program är klassen Anställd inkapslad eftersom variablerna är privata. Det är möjligt att läsa och skriva implementeringen eftersom den har fått och ställt in metoder. De privata variablerna som EmpName, EmpSal, EmpID nås med hjälp av dessa metoder och visas genom att anropa metoderna med objektet.
Låt oss nu se hur inkapsling fungerar med skrivskyddad klass.
Exempel 2
- Employee.java
Koda:
//Java program for Encapsulation with read permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName = "Adam";
private int EmpID = 670388;
private int EmpSal = 35000;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(return EmpSal;
)// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
)
- EmployeeEncaps.java
Koda:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Produktion:
I likhet med det första exemplet använder vi också privata variabler. Skillnaden är att vi inte använder uppsättningsmetoden för att ställa in värden för de privata variablerna i klassen. Istället tilldelar vi värdet direkt till variablerna.
Nu kan vi gå vidare till att bara skriva klass.
Exempel 3
- Employee.java
Koda:
//Java program for Encapsulation with write permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
//for sample output
System.out.println("Employee's Salary: " + EmpSal);
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
//for sample output
System.out.println("Employee's Name: " + EmpName);
)// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
//for sample output
System.out.println("Employee's ID: " + EmpID);
)
)
- EmployeeEncaps.java
Koda:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj = new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Iza");
EmpObj.setEmpID(670472);
EmpObj.setEmpSal(48000);
)
)
Produktion:
I exemplet ovan använder vi inte get-metoden för att uppnå endast skrivklass. dvs variablerna kan inte ändras eller hämtas här. Eftersom det inte går att få värdena använder vi utskrift i den inställda metoden för provutgång.
Slutsats
Inkapsling är ett OOP-koncept där data kommer att förpackas döljer alla implementeringsdetaljer. Det kan uppnås genom att använda privata variabler och metoder som att få, inställd för att komma åt variablerna. De viktigaste fördelarna med inkapsling inkluderar flexibilitet, gömning av data, enkelhet i testning och återanvändbarhet .
Rekommenderade artiklar
Detta har varit en guide till Encapsulation i Java. Här diskuterar vi hur fungerar inkapsling, exempel på Java-inkapsling med koder och utdata. Du kan också gå igenom våra givna artiklar för att lära dig mer-
- Destructor i Java
- Layout i Java
- Bästa Java-kompilatorer
- Guide till inkapsling i C ++
- Varför behöver vi inkapsling i C?
- Översikt över inkapsling i JavaScript