Introduktion till det slutliga nyckelordet i Java
I det här inlägget ska vi titta på de olika slutliga nyckelorden för java. Det är ett nyckelord som används på java-språk för att tillämpa begränsningar för dess användning eller ändring av andra klasser eller variabler. Med hjälp av detta sökord berättar man för tolkaren att inte tillåta någon framtida modifiering av den variabeln eller metoden och behandla den som konstant. Det kan användas med nedan tre scenarier: -
- Variabel: Att förklara en variabel som slutlig begränsar dess modifiering för att hänvisa till något annat värde eller referens.
- Metoder: Att förklara en metod som slutlig begränsar metodöverskridande av metoden i barnklasserna.
- Klasser: Att förklara en klass som slutgiltig förhindrar den klassens arv.
Dessa nyckelord rekommenderas alltid att deklareras med stora bokstäver enligt god kodningssed.
Syntax för det slutliga sökordet i Java
Detta sökord kan användas på nedan tre sätt: -
1. Variabel
Variabler i java kan deklareras som variabel för att begränsa alla ändringar i dess värden. Det kan förklaras på något av följande tre sätt-
Syntax:
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 = new StringBuilder (“LetsLearn”);
2. Metoder
Metoden som deklareras med det slutliga nyckelordet sägs vara den slutliga metoden. Den slutliga metoden kan inte åsidosättas av dess barnklass, vilket innebär att barnklassmetoden inte kan ändra definitionen av den slutliga metoden som finns i förälderklassen. När vi vill att implementeringen av en metod som definieras i moderklassen måste följas i alla barnklasser måste vi förklara den metoden som slutlig.
Syntax:
final int my1()(
//method defination
)
3. Klasser
Slutliga nyckelord kan också användas med klasser för att göra det till en slutklass som innebär att den klassen inte kan förlängas eller ärvas av andra klasser.
Syntax:
final class myClass(
/member variables and member functions.
)
Hur fungerar det slutliga nyckelordet i Java?
Det sista nyckelordet hjälper till att begränsa åsidosättandet av klasser, medlemmar eller variabler under arv.
1. Slutvariabler
Att förklara en variabel som slutlig innebär att alla ändringar begränsas till värdet på variabeln i de ärvda klasserna. En slutvariabel kan endast initialiseras en gång och måste användas som den är, så man måste initialisera en slutvariabel. Det används mest med statisk för att skapa en konstant klassvariabel.
Till exempel:
final int a =0;
Vi kan också förklara referensvariabler som slutliga, i det här fallet kan en referensvariabel inte referera till olika objekt. Men i java kan det interna tillståndet för ett objekt ändras som hänvisas till av den slutliga referensvariabeln. Således kan vi göra ändringar i värdet på referensvariabeln. Detta är samma sak som att använda slutliga matriser som visas nedan: -
Koda:
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));
)
)
)
Produktion:
Förklaring
Här hänvisar array a1 till samma objekt bara värdet på det objektet förändras eftersom vi alla vet att variabeln i arrayen bara innehåller startadressen för minnesplatsen där elementen i arrayen lagras.
Och på samma sätt, om vi försöker att hänvisa till olika array med samma arrayvariabel a1, kommer ett fel att kastas av kompilatorn. Genom att använda ord-slutlig matris här betyder all ändring kan göras på gruppens medlem men variabeln får inte hänvisa till något annat objekt.
Saker att komma ihåg
Att initiera en slutlig variabel är nödvändig för att förhindra kompileringstidsfel. Det finns en skillnad mellan C ++ const-variabler och dessa slutliga variabler som const-variabler behöver inte initialiseras. Det finns tre sätt att initialisera en slutlig variabel-
- Initiera vid själva deklarationen : Vi kan enkelt förklara en slutlig variabel vid tidpunkten för att deklarera den. Om det inte initialiseras så betraktas den variabeln som en tom slutvariabel, och något av de kommande två sätten kan hjälpa oss att initialisera en tom slutvariabel.
- Använda instansinitieringsblock : Inuti detta block eller konstruktören kan en tom slutvariabel enkelt initialiseras. Kom ihåg att alltid initialisera den specifika variabeln i alla tillgängliga konstruktörer när du använder en konstruktör för att initialisera.
- Statisk block: Man kan också använda ett statiskt block för att initialisera den tomma slutvariabeln. Statiskt block utlöses alltid en gång för varje klass, varför det variabla värdet vars värden inte är tänkt att ändras lätt kan initialiseras med detta block.
Således används det slutliga nyckelordet endast för den variabeln som inte behöver ändra deras värde under körningen av programmet. Alla de slutliga variabler som skapas i en metod eller block måste initialiseras där själv. Sådana typvariabler kallas lokala slutliga variabler.
Förklaring
I exemplet nedan har en variabel i deklarerats inom huvudfunktionen och initialiserats betraktas således också som en slutlig lokal variabel.
Koda:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Produktion:
2. Slutliga metoder
En metod som förklaras som slutlig kan inte åsidosättas i någon av underklasserna, så kallade som slutlig metod. Metoden måste förklaras som slutlig om vi kräver att samma implementering av klassen följs av barnklasserna.
Obs - Det är inte nödvändigt att slutliga metoder deklareras i det första arvsfasen (basklass). Metoden kan förklaras slutgiltig i alla underklasser som vi vill att ytterligare underklasser ska följa samma definition.Koda:
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. Slutklasser
Klasser som deklareras som slutgiltiga kan inte ärvas av andra klasser. När jag nämner ett slutligt nyckelord innan klassnamnet säger kompilatorn att definitionen av denna klass endast kan användas som de är. Inga andra klasser kan lägga till sina specifikationer i denna definition eller återanvända dess kod. Om man försöker förlänga den slutliga klassen kastas ett fel av kompilatorn som indikerar att denna klass inte är avsedd att utvidgas. Man kan använda slutliga nyckelord i java i vilket som helst för under 2 syften: -
- Den första är att förhindra arv från den klassen. För t.ex. - alla Wrapper-klasser som finns med java.lang-paketet är slutklasser därför kan vi inte utöka dem i våra klasser men kan använda det genom att förklara deras objekt. Alla försök att komma åt dessa klasser kommer att resultera i ett fel av kompilatorn.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Den andra användningen av final med klasser är när man behöver skapa en oföränderlig klass, dvs när klassens objekt har skapats kan vi inte ändra dess innehåll som den fördefinierade String-klassen. Klassen måste förklaras som slutlig för att göra den oföränderlig.
Notera :
- Om en klass förklaras som slutlig, betraktas dess medlemsvariabler och medlemsfunktioner också som slutliga av kompilatorn.
- En klass kan inte förklaras abstrakt när den är beroende av barnklasserna för att slutföra sin definition såväl som slutlig som förhindrar själva arvet.
Exempel på slutligt sökord i Java
Nedan följer de olika exemplen på det slutliga nyckelordet i Java:
1. Använd slutlig variabel
I exemplet nedan initialiseras olika variabler med olika metoder. Till exempel initialiseras den andra variabeln med konstruktör medan THIRD initieras med hjälp av en initialisator.
Koda:
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
)
)
Produktion:
2. Använd slutliga metoder
I exemplet nedan förklarar abstrakt klass myShape slutliga metoder getWidth och få åtta som inte behöver åsidosättas av de ärvda klasserna. Det förklarar också en abstrakt funktion vars implementering är obligatorisk i de efterföljande klasserna. Således implementeras den enda definitionen av en abstrakt funktion i en första barnklass och andra barnklass.
Koda:
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());
)
)
Produktion:
3. Använda finalklasser
I nedanstående program använder vi en sista klass Solid som definierar en metod för att beräkna en formvolym med hjälp av dess dimensioner, men visning av en lådans volym görs med funktionen printVol i den ärvda klassen. Shape Eftersom Solid är en sista klass, kommer klass Shape inte att tillåta att förlänga (eller ärva) den. Således använder det Shape-objektet för att beräkna volymen för någon av Shape genom att bara skicka argumenten till funktionerna.
Koda:
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);
)
)
Produktion:
Slutsats
Det sista nyckelordet används för att förhindra att klasser, variabler och metoder åsidosätts av sina barnklasser. Det kan också användas för att göra klasser oföränderliga som begränsar förändringen i värdet på dess objekt. Den sista sökordskontrollen kontrolleras alltid endast vid sammanställningstiden. Det är ett bra verktyg för att förhindra återanvändning av de definierade variablerna, logiken och klasserna.
Rekommenderade artiklar
Detta är en guide till exempel på Final Key i Java. Här diskuterar vi hur det slutliga nyckelordet fungerar i java? som inkluderar slutliga variabler, slutliga metoder, slutklasser tillsammans med syntax. Du kan också titta på följande artiklar för att lära dig mer -
- Typer och modifierare som används för JComponent i Java
- Nya funktioner i Java 8
- Hur skapar jag ett objekt i JavaScript?
- Vad är ärendeuttalande i JavaScript?
- Kast vs kastar | Topp 5 skillnader du borde veta
- Förklara abstrakt klass i C # med exempel
- Användningar och exempel på detta sökord