Bevezetés a Java kulcsszójához
Ebben a bejegyzésben megvizsgáljuk a java különféle végső kulcsszavait. Ez egy kulcsszó, amelyet a java nyelven használnak korlátozásokra annak használatára, vagy más osztályok vagy változók módosítására. E kulcsszó használata azt mondja a tolmácsnak, hogy ne engedje meg a változó vagy módszer későbbi módosítását, és állandóként kezelje. 3 forgatókönyv alatt használható: -
- Változó: A változó véglegesnek nyilvánítása korlátozza annak módosítását, hogy bármilyen más értékre vagy referenciára hivatkozzon.
- Módszerek: A módszer véglegesnek nyilvánítása korlátozza a módszer felülírását a gyermekórákban.
- Osztályok: Az osztály véglegesnek nyilvánítása megakadályozza az osztály öröklését.
Ezeket a kulcsszavakat mindig javasoljuk, hogy a helyes kódolási gyakorlatnak megfelelõen nyomtatják nagybetûvel.
A végső kulcsszó szintaxisa Java-ban
Ez a kulcsszó háromféleképpen használható: -
1. Változó
A java változói változóként deklarálhatók, hogy az értékek bármilyen változását korlátozzák. Három alatti módon lehet bejelenteni -
Szintaxis:
final int VAR1=21;//final variable
final int VAR2; //blank final variable
static final double DUMMY= 45.504;//final static variable
static final double PK;//blank final static variable
final String builder sb = új StringBuilder (“LetsLearn”);
2. Módszerek
Azt állítják, hogy a végső kulcsszóval deklarált módszer a végleges módszer. A végső módszert nem szabad felülbírálni gyermekkori osztályán, ami azt jelenti, hogy a gyermekosztály módszer nem változtathatja meg a szülői osztályban lévõ végleges módszer meghatározását. Ha azt akarjuk, hogy a szülői osztályban meghatározott módszer végrehajtását minden gyermekosztályban kövesse, akkor ezt a módszert véglegesnek kell nyilvánítani.
Szintaxis:
final int my1()(
//method defination
)
3. Osztályok
A végső kulcsszavak az osztályokkal is felhasználhatók, hogy végső osztályt képezzenek, ami azt jelenti, hogy az adott osztályt nem lehet kibővíteni vagy örökölni más osztályokkal.
Szintaxis:
final class myClass(
/member variables and member functions.
)
Hogyan működik a végső kulcsszó a Java-ban?
A végső kulcsszó segít korlátozni az osztályok, tagok vagy változók felülbírálását az öröklés során.
1. Végső változók
A változó véglegesnek nyilvánítása azt jelenti, hogy az örökölt osztályokban a változó értékére vonatkozó bármilyen változást korlátozni kell. A végső változó csak egyszer inicializálható, és a jelenlegi formában kell használni, tehát egy végső változót inicializálni kell. Leginkább statikusan használják állandó osztályváltozó létrehozására.
Például:
final int a =0;
A referenciaváltozókat véglegesnek is nyilváníthatjuk, ebben az esetben egy referenciaváltozó nem hivatkozhat különféle objektumokra. De a java-ban megváltoztatható egy objektum belső állapota, amelyet a végső referenciaváltozó utal. Így megváltoztathatjuk a referenciaváltozó értékét. Ez ugyanaz, mint az alábbiakban bemutatott végső tömbök használata: -
Kód:
class MyClass
(
public static void main(String args())
(
final int myarr() = (1, 2, 3, 4, 5);
for (int q = 0; q < myarr.length; q++)
(
myarr (q) = myarr (q)*10;
System.out.println(myarr (q));
)
)
)
Kimenet:
Magyarázat
Az a1 tömb ugyanarra az objektumra utal, csak az objektum értéke változik, mert mindannyian tudjuk, hogy a tömb változója csak a memóriahely kezdőcímét tartalmazza, ahol a tömb elemei tárolódnak.
Ugyanebben az esetben, ha megpróbálunk különbözõ tömböket hivatkozni ugyanazon a1 tömbváltozóval, akkor a fordító hibát dob. Tehát a szó végső tömb használata itt azt jelenti, hogy a tömb tagját bármilyen módon megváltoztathatjuk, de a változó nem engedhet meg, hogy más objektumra hivatkozzon.
Dolgok, amikre emlékezni kell
A végleges változó inicializálása szükséges a fordítási idő hiba elkerülése érdekében. Különbség van a C ++ const változók között, és ezek a végső változók azt mutatják, hogy a const változókat nem kell inicializálni. Három módon lehet inicializálni a végső változót -
- Inicializálja magát a nyilatkozat időpontjában : A végső változót deklarálhatjuk könnyen. Ha nem inicializálják, akkor ezt a változót üres végleges változónak kell tekinteni, és a következő 2 módszer bármelyike segíthet nekünk egy üres végső változó inicializálásában.
- Példány-inicializáló blokk használata : Ezen a blokon vagy a konstruktoron belül egy üres végső változó könnyen inicializálható. Miközben konstruktort használ az inicializáláshoz, ne felejtse el inicializálni az adott változót az összes rendelkezésre álló konstruktorban.
- Statikus blokk: Statikus blokkot is lehet használni az üres végső változó inicializálásához. A statikus blokk minden egyes osztálynál mindig egyszer aktiválódik, így a változó értéke, amelynek az értékeit nem szándékozik megváltoztatni, ezzel a blokkkal könnyen inicializálható.
Így a végső kulcsszót csak azokhoz a változókhoz használják, amelyeknek nem kell megváltoztatniuk értéküket a program végrehajtása során. Az eljárásban vagy blokkban létrehozott összes végső változót ott kell inicializálni. Az ilyen típusú változókat helyi végső változóknak nevezik.
Magyarázat
Az alábbi példában egy i változót deklaráltunk a főfüggvényen belül, és inicializáltuk tehát végső helyi változónak is.
Kód:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Kimenet:
2. Végső módszerek
A véglegesnek nyilvánított módszert egyik alosztályban sem szabad felülbírálni, úgynevezett végleges módszerként. A módszert véglegesnek kell nyilvánítani, ha megköveteljük, hogy az osztály ugyanazt a megvalósítását a gyermekórák kövessék.
Megjegyzés : Nem szükséges, hogy a végleges módszereket az öröklés kezdeti szakaszában (alaposztály) deklarálják. A módszer bármely alosztályban véglegesnek nyilvánítható, ha azt akarjuk, hogy további alosztályok ugyanazt a meghatározást kövessék.Kód:
class A(
void myMethod()(
//method definition
)
)
class B extends A(
final void myMethod()(
//overrides the method in parent class
//runs successfully
)
)
class C extends B(
void myMethod()(
//will throw error
)
)
3. Záró osztályok
A véglegesnek nyilvánított osztályokat egyetlen osztály sem örökölheti. Az utolsó kulcsszó megemlítése az osztálynév előtt azt mondja a fordítónak, hogy ennek az osztálynak a meghatározása csak olyan lehet, ahogy van. Más osztályok nem adhatják hozzá specifikációikat ehhez a meghatározáshoz, vagy nem használhatják újra a kódot. Abban az esetben, ha megpróbálják kibővíteni a végső osztályt, a fordító hibát dob, jelezve, hogy ezt az osztályt nem szabad kiterjeszteni. A java-ban szereplő kulcsszavak 2-nél kevesebb célt szolgálhatnak: -
- Az első az, hogy megakadályozzuk az osztály öröklését. Például: a jelenlegi Wrapper osztályokhoz a java.lang csomag végső osztályokat képez, ezért nem tudjuk kibővíteni őket osztályukban, hanem felhasználhatjuk tárgyuk deklarálásával. Az ezen osztályokhoz való hozzáférés bármilyen kísérlete hibát eredményez a fordító által.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Az osztályok végső használatának második alkalma az, ha megváltoztathatatlan osztályt kell létrehozni, azaz amikor az osztály tárgya létrejön, nem változtathatjuk meg annak tartalmát, mint az előre definiált karakterlánc osztály. Az osztályt véglegesnek kell nyilvánítani, hogy változatlan legyen.
Jegyzet :
- Ha egy osztályt véglegesnek nyilvánítanak, akkor annak tagváltozóit és tagfüggvényeit a fordító is véglegesnek veszi.
- Az osztályt nem lehet absztraktnak nyilvánítani, ha a gyermekosztályoktól függ annak meghatározása, valamint végleges, amely megakadályozza magát az öröklést.
Példák a végső kulcsszóra a Java-ban
Az alábbiakban a Java végső kulcsszó különféle példái találhatók:
1. A végső változó használata
Az alábbi példában a különböző változók különféle módszerekkel vannak inicializálva. Például: a MÁSODIK változót konstruktorral inicializálják, míg a THIRD-t inicializálóval inicializálják.
Kód:
class myClass
(
final int FIRST = 5;
// a blank final variable
final int SECOND;
// another blank final variable
final int THIRD;
FIRST =10; //illegal attempt to change the value of final variable
// a final static variable PI
// direct initialize
static final double MINVALUE = 3.141592653589793;
// a blank final static variable
static final double MAXRANGE;
(
THIRD = 25; // initializer block
)
static(
MAXRANGE = 200.3;
)
public myClass()
(
SECOND = -1;//needs to be initialised in every constructor
)
)
Kimenet:
2. A végső módszerek használata
Az alábbi példában az absztrakt osztály a myShape deklarálja a getWidth végső módszereket és nyolcot kap, amelyeket nem szabad felülbírálni az örökölt osztályok által. Egy absztrakt függvényt is deklarál, amelynek végrehajtása a következő osztályokban kötelező. Így az absztrakt funkció egyetlen meghatározását az első gyermekosztályban és a második gyermekosztályban is végrehajtják.
Kód:
abstract class myShape
(
private double width;
private double height;
public myShape(double width, double height)
(
this.width = width;
this.height = height;
)
public final double getWidth() //override not allowed
(
return width;
)
public final double getHeight() //override not allowed
(
return height;
)
abstract double getArea(); //needs to be defined in the child class
)
class firstChildClass extends myShape
(
public firstChildClass(double width, double height)
(
super(width, height);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
class secondChildClass extends myShape
(
public secondChildClass(double side)
(
super(side, side);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
public class myClass
(
public static void main(String() args)
(
myShape s1 = new firstChildClass(10, 20);
myShape s2 = new secondChildClass(10);
System.out.println("width of s1 : "+ s1.getWidth());
System.out.println("height of s1 : "+ s1.getHeight());
System.out.println("width of s2 : "+ s2.getWidth());
System.out.println("height of s2 : "+ s2.getHeight());
System.out.println("area of s1 : "+ s1.getArea());
System.out.println("area of s2 : "+ s2.getArea());
)
)
Kimenet:
3. Záró osztályok használata
Az alábbi programban egy olyan Solid végső osztályt használunk, amely meghatározza az alak méretének kiszámításához használt módszert, de a doboz térfogatának megjelenítéséhez az print örömében az printVol függvényt használjuk. Alak, mivel a szilárd anyag végső osztály, tehát az alak alakja nem fogja meghosszabbítani (vagy öröklni). Így a Shape objektumot használja az Shape bármelyikének térfogatának kiszámításához az argumentumok átadásával a függvényekhez.
Kód:
final class Solid (
public double getVol(double length, double width, double height) (
return length * width * height;
)
)
class Shape (
private float length;
private float width;
private float height;
Shape(float length, float width, float height) (
this.length = length;
this.width = width;
this.height = height;
)
public void printVol(Solid bObj) (
double volume = bObj.getVol(this.length, this.width, this.height);
System.out.println("Volume of the Shape: " + volume);
)
)
public class myClass (
public static void main(String() args) (
Solid bObj = new Solid();
Shape obj = new Shape(5, 4, 3);
obj.printVol(bObj);
)
)
Kimenet:
Következtetés
A végső kulcsszót arra használják, hogy megakadályozzák az osztályokat, a változókat és a módszereket a gyermek osztályok felett. Arra is felhasználható, hogy osztályok változhatatlanná váljanak, ami korlátozza az objektumok értékének változását. A végső kulcsszóellenőrzést mindig csak a fordítási időben ellenőrzik. Ez egy nagyszerű eszköz a meghatározott változók, logika és osztályok újrafelhasználásának megakadályozására.
Ajánlott cikkek
Ez egy útmutató a Java végső kulcsszójának példájához. Itt tárgyaljuk, hogyan működik a végső kulcsszó java-ban? amely magában foglalja a végső változókat, a végleges módszereket, a végső osztályokat és a szintaxist. A következő cikkeket is megnézheti további információkért -
- A JComponent Java-ban használt típusai és módosítói
- A Java 8 új szolgáltatásai
- Hogyan lehet objektumot létrehozni JavaScript-ben?
- Mi az esettanulmány a JavaScript-ben?
- Dobás és dobás | Öt legfontosabb különbség, amelyet tudnia kell
- Absztrakt osztály deklarálása a C # példában
- A kulcsszó felhasználásai és példái