Bevezetés a Java beágyazásához
A beágyazás a Java négy alapvető objektum-orientált programozási koncepciójának egyike. Ennek fő gondolata a megvalósítás részleteinek elrejtése a felhasználók részéről. Más szavakkal: az Encapsulation az adatok csomagolása egyetlen egységbe annak érdekében, hogy megakadályozzuk az adatokhoz való hozzáférést a külvilágtól. Mivel az adatok el vannak rejtve a többi osztálytól, ez a folyamat adatrejtő néven is ismert. Vegyük példa az izzó működését. Nem is tudjuk az izzó mögötti tényleges működést, még akkor is, ha használjuk. A Java Encapsulation esetében azonban módosítók segítségével hozzáférhet az adatokhoz. Vizsgáljuk meg a következő részben.
Hogyan működik a beágyazás a javaban?
Az Encapsulation Java alkalmazásban működik
- Az osztály attribútumait vagy változóit magánnak nyilvánítja
Például létrehozunk egy Munkavállalói osztályt. A változókat privátként kell beállítani, az alább látható módon.
private String EmpName;
private int EmpID;
private int EmpSal;
- Nyilvános módszerek létrehozása az osztályban az attribútumok vagy változók beszerzése és beállítása céljából.
Az alábbiakban bemutatjuk a get módszert és a beállított módszert a Munkavállaló osztály különféle magánváltozóira.
Kód:
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;
)
Ezekkel a módszerekkel lehetséges az osztály írása vagy írása, azaz ezeket a módszereket ki is hagyhatjuk, ha erre szükség van.
Az alábbiakban bemutatjuk a beágyazás előnyeit.
- Az alkalmazás egyszerűsége
- Képesség a kód újrafelhasználására vagy módosítására a követelmények alapján
- Korlátozza az adatok hozzáférhetőségét
- Könnyű az egység tesztelése, mivel a kódot beágyazták
A Java Bean Class az egyik példa a teljesen beágyazott osztályra, mivel az osztály összes adattagja magán.
Példák a Java beágyazásra
Lássunk egy példát a beágyazásról mind getter, mind setter módszerekkel. Ehhez hozzon létre 2 osztályt - az egyiket a fő módszerrel, a másikat a beszerzési és beállítási módszerrel.
1. példa
- Employee.java
Kód:
//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
Kód: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());
)
)
Kimenet:
A fenti programban a Munkavállalói osztály be van ágyazva, mivel a változók privát jellegűek. Lehetséges olvasni és írni a megvalósítást, mivel megkapta és beállította a módszereket. Az olyan privát változókat, mint az EmpName, EmpSal, EmpID, ezekkel a módszerekkel lehet elérni, és az objektumot használó módszerek meghívásával jelennek meg.
Most nézzük meg, hogyan működik az Encapsulation a írásvédett osztályban.
2. példa
- Employee.java
Kód:
//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
Kód:
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());
)
)
Kimenet:
Az első példához hasonlóan itt is privát változókat használunk. A különbség az, hogy nem a set módszert használjuk az osztály magánváltozóinak értékének beállításához. Ehelyett az értéket közvetlenül hozzárendeljük a változókhoz.
Most továbbmehetünk, hogy csak osztályt írjunk.
3. példa
- Employee.java
Kód:
//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
Kód:
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);
)
)
Kimenet:
A fenti példában nem a get módszert használjuk a csak írás osztály elérésére. azaz a változók itt nem módosíthatók és nem állíthatók elő. Mivel az értékek nem szerezhetők be, a minta kinyomtatására a beállított módszer belsejében nyomtatunk.
Következtetés
A beágyazás egy olyan OOP-koncepció, amelyben az adatok be vannak csomagolva, és elrejtik a végrehajtás részleteit. Ezt úgy érhetjük el, hogy olyan privát változókat és módszereket használunk, amelyek segítségével megkaphatjuk, beállíthatjuk a változók elérését. Az Encapsulation fő előnyei a rugalmasság, az adatok elrejtése, a tesztelés egyszerűsége és az újrafelhasználhatóság .
Ajánlott cikkek
Ez egy útmutató a Java beágyazáshoz. Itt tárgyaljuk, hogyan működik a beágyazás, példákat találhatunk a Java beágyazásra a kódokkal és a kimenettel. Megnézheti az adott cikkeket is, hogy többet megtudjon-
- Destructor Java
- Elrendezés Java-ban
- A legjobb Java fordítók
- Útmutató a C ++ beágyazásához
- Miért van szükség a C beágyazásra?
- A beágyazás áttekintése a JavaScript-ben