Lõppsõna sissejuhatus Java-sse
Selles postituses vaatame java erinevaid lõplikke märksõnu. See on märksõna, mida java keeles kasutatakse, et piirata selle kasutamist või muude klasside või muutujate muutmist. Selle märksõna kasutamine käsib tõlgil keelata muutuja või meetodi edaspidiseid muudatusi ja käsitada seda konstantsena. Seda saab kasutada allpool toodud 3 stsenaariumi korral: -
- Muutuja: Muutuja lõplikuks kuulutamine piirab selle muutmist mis tahes muule väärtusele või viitele.
- Meetodid: Meetodi lõplikuks kuulutamine piirab selle meetodi ülimuslikkust lasteklassides.
- Klassid: klassi lõplikuks kuulutamine takistab selle klassi pärandit.
Need märksõnad soovitatakse alati vastavalt headele kodeerimise tavadele trükkida suurtähtedega.
Lõppsõna süntaks Java-s
Seda märksõna saab kasutada allpool kolmel viisil: -
1. Muutuv
Java muutujaid saab muutujatena kuulutada, et nende väärtuste mis tahes muudatusi piirata. Selle saab deklareerida ühel järgmistest viisidest -
Süntaks:
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
lõplik Stringi ehitaja sb = uus StringBuilder (“LetsLearn”);
2. Meetodid
Lõplikuks märksõnaks deklareeritud meetodit peetakse lõplikuks meetodiks. Lõplikku meetodit ei saa selle lasteklass ümber lükata, see tähendab, et lasteklassi meetod ei saa muuta vanemklassis esineva lõpliku meetodi määratlust. Kui soovime, et vanema klassis määratletud meetodi rakendamist tuleks järgida kõigis lasteklassides, peame selle meetodi lõplikuks kuulutama.
Süntaks:
final int my1()(
//method defination
)
3. klassid
Lõplikke märksõnu saab klassidega kasutada ka lõpuklassiks muutmiseks, mis tähendab, et konkreetset klassi ei saa laiendada ega pärida ükski teine klass.
Süntaks:
final class myClass(
/member variables and member functions.
)
Kuidas lõplik märksõna Java töötab?
Viimane märksõna aitab piirata klasside, liikmete või muutujate ülevõtmist pärimise ajal.
1. Lõplikud muutujad
Muutuja lõplikuks kuulutamine tähendab muutuja väärtuse piiramist päritud klassides. Lõplikku muutujat saab lähtestada ainult üks kord ja seda tuleb kasutada sellisena, nagu see on, seega tuleb lähtemuutuja lähtestada. Seda kasutatakse enamasti koos staatilise süsteemiga, et luua püsiklassimuutuja.
Näiteks:
final int a =0;
Võime ka muutuda võrdlusmuutujateks lõplikuks, sel juhul ei saa üks viitemuutuja viidata erinevatele objektidele. Kuid javas saab muuta objekti sisemist olekut, millele viitab viimane võrdlusmuutuja. Seega saame referentsmuutuja väärtuses muudatusi teha. See on sama, kui kasutada allpool toodud lõplikke massiive: -
Kood:
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));
)
)
)
Väljund:
Seletus
Massiiv a1 viitab siin samale objektile, ainult selle objekti väärtus muutub, kuna me kõik teame, et massiivi muutuja sisaldab ainult selle mälu asukoha algusaadressi, kuhu massiivi need elemendid on salvestatud.
Ja kui proovime sama massiivi muutuja a1 abil viidata erinevatele massiividele, viskab kompilaator vea. Seega tähendab sõna-lõppmassiivi kasutamine siin kõiki massiivi liikme muudatusi, kuid muutujal pole lubatud ühelegi teisele objektile viidata.
Asjad, mida meeles pidada
Lõpliku muutuja lähtestamine on vajalik kompileerimisaja vea vältimiseks. C ++ const muutujate vahel on erinevus ja need lõplikud muutujad, et const muutujaid ei pea lähtestama. Lõpliku muutuja lähtestamiseks on kolm viisi -
- Initsialiseerige deklareerimise ajal ise : lõpliku muutuja saab selle deklareerimise ajal hõlpsalt deklareerida. Kui seda ei initsialiseerita, loetakse seda muutujat tühjaks lõplikuks muutujaks ja üks järgmistest kahest viisist võib aidata meil tühja lõpliku muutuja lähtestada.
- Eksemplaride initsiaatori ploki kasutamine : selle ploki või konstruktori sees saab tühja lõpliku muutuja hõlpsalt initsialiseerida. Konstrueerija initsialiseerimisel tuleb alati meeles pidada muutuja lähtestamist kõigis saadaolevates konstruktorites.
- Staatiline plokk: tühja lõpliku muutuja lähtestamiseks saab kasutada ka staatilist plokki. Staatiline plokk käivitatakse alati iga klassi jaoks üks kord, seega saab muutuja väärtust, mille väärtusi ei taheta muuta, selle ploki abil hõlpsalt käivitada.
Seega kasutatakse lõplikku märksõna ainult nende muutujate jaoks, mille programmi täitmise ajal ei pea nende väärtust muutma. Kõik meetodi või ploki sees loodud lõplikud muutujad tuleb seal ise initsialiseerida. Selliseid tüüpi muutujaid tuntakse kohalike lõplike muutujatena.
Seletus
Allpool toodud näites on muutuja i deklareeritud põhifunktsiooni piires ja initsialiseeritud ning seetõttu loetakse seda ka lõplikuks lokaalseks muutujaks.
Kood:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Väljund:
2. Lõplikud meetodid
Lõplikuks kuulutatud meetodit ei saa üheski alaklassis tühistada, seega nimetatakse seda lõplikuks meetodiks. Meetod tuleb kuulutada lõplikuks, kui nõuame, et sama klassi rakendamist järgitaks ka lapsetundides.
Märkus. Lõplikke meetodeid ei ole vaja deklareerida pärimise algfaasis (põhiklass). Meetodi saab lõplikuks kuulutada igas alaklassis, mille puhul soovime, et ka teised alaklassid järgiksid sama määratlust.Kood:
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. Lõpuklassid
Lõplikuks kuulutatud klasse ei saa pärida ükski teine klass. Lõpliku märksõna mainimine klassi nime ees ütleb koostajale, et selle klassi määratlust saab kasutada ainult sellisena, nagu nad on. Ükski teine klass ei saa sellele määratlusele oma spetsifikatsioone lisada ega selle koodi uuesti kasutada. Kui üritatakse lõpuklassi laiendada, viskab koostaja vea, mis näitab, et selle klassi laiendamine pole mõeldud. Lõplikke märksõnu javas võib kasutada ükskõik millisel juhul kahel juhul: -
- Esimene on selle klassi pärandi ärahoidmine. Näiteks - kõik olemasolevad pakenditunnid java.lang - pakett on selle jaoks lõpuklassid, seetõttu ei saa me neid klassides laiendada, vaid saame seda kasutada nende objektide deklareerimisel. Mis tahes katse neile klassidele juurde pääseda põhjustab kompilaatori vea.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Klasside finaali teine kasutamine on siis, kui tuleb luua muutumatu klass, st kui klassi objekt on loodud, ei saa me selle sisu muuta nagu eelmääratud keelpilliklass. Klass tuleb kuulutada lõplikuks, et muuta see muutumatuks.
Märge :
- Kui klass kuulutatakse lõplikuks, loetakse ka koostaja selle liikme muutujateks ja liikmefunktsioonideks lõplikuks.
- Klassi ei saa kuulutada abstraktseks, kui selle määratluse lõpuleviimine sõltub lasteklassidest ja ka lõplik, mis takistab pärandit ennast.
Lõpliku märksõna näited Java keeles
Allpool on Java lõpliku märksõna erinevad näited:
1. Lõpliku muutuja kasutamine
Allpool toodud näites lähtestatakse erinevad muutujad, kasutades erinevaid meetodeid. Näiteks lähtestatakse SECOND muutuja konstruktori abil, THIRD initsialiseeritakse initsiaatori abil.
Kood:
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
)
)
Väljund:
2. Lõplike meetodite kasutamine
Allpool toodud näites deklareerib abstraktne klass myShape lõplikud meetodid getWidth ja saada kaheksa neid, mida ei pea päritud klassid ületama. Samuti deklareeritakse üks abstraktne funktsioon, mille rakendamine on järgnevates klassides kohustuslik. Seega rakendatakse abstraktse funktsiooni ainus määratlus nii esimeses kui ka teises lasteklassis.
Kood:
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());
)
)
Väljund:
3. Lõpuklasside kasutamine
Allpool olevas programmis kasutame viimast klassi Solid, mis määratleb meetodi kuju mahu arvutamiseks selle mõõtmete järgi, kuid kasti mahu kuvamine toimub päritud klassi funktsiooni printVol abil. Kuju Kuna tahke aine on lõpuklass, ei tohi klassi kuju seda pikendada (ega pärandada). Seega kasutab ta kuju Shape, et arvutada välja ükskõik millise kuju maht, edastades argumendid funktsioonidele.
Kood:
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);
)
)
Väljund:
Järeldus
Lõplikku märksõna kasutatakse klasside, muutujate ja meetodite vältimiseks selle lasteklasside poolt. Seda saab kasutada ka klasside muutmatuks muutmiseks, mis piirab objektide väärtuse muutumist. Lõplikku märksõna kontrollimist kontrollitakse alati ainult kompileerimise ajal. See on suurepärane utiliit määratletud muutujate, loogika ja klasside korduskasutuse vältimiseks.
Soovitatavad artiklid
See on juhend Java lõpliku märksõna näitest. Siin arutleme selle üle, kuidas lõplik märksõna javas töötab? mis sisaldab lõplikke muutujaid, lõplikke meetodeid, lõpuklasse koos süntaksiga. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -
- JComponenti jaoks Java-s kasutatavad tüübid ja modifikaatorid
- Java 8 uued funktsioonid
- Kuidas luua objekti JavaScriptis?
- Mis on kohtuasja avaldus JavaScriptis?
- Viska vs viskab | 5 parimat erinevust, mida peaksite teadma
- C-klassi abstraktse klassi kuulutamine näitega
- Selle märksõna kasutusalad ja näited