The konečná metoda v Javě se používá jako a modifikátor nepřístupu platí pouze pro a variabilní , a metoda , nebo a třída. Je zvyklý omezit uživatele v Javě .

Následující jsou různé kontexty kde se používá koncovka:

1. Variabilní
2. Metoda
3. Třída

Charakteristika finálního klíčového slova v Javě:

V Javě se klíčové slovo final používá k označení toho, že proměnnou, metodu nebo třídu nelze upravit nebo rozšířit. Zde jsou některé z jeho charakteristik:

• Konečné proměnné: Když je proměnná deklarována jako konečná, nelze její hodnotu po inicializaci změnit. To je užitečné pro deklarování konstant nebo jiných hodnot, které by neměly být upravovány.
• Závěrečné metody : Když je metoda deklarována jako konečná, nelze ji přepsat podtřídou. To je užitečné pro metody, které jsou součástí veřejného API třídy a neměly by být upravovány podtřídami.
• Závěrečné třídy: Když je třída deklarována jako konečná, nelze ji rozšířit o podtřídu. To je užitečné pro třídy, které jsou určeny k použití tak, jak jsou, a neměly by být upravovány ani rozšiřovány.
• Inicializace: Finální proměnné musí být inicializovány buď v době deklarace, nebo v konstruktoru třídy. Tím je zajištěno, že hodnota proměnné je nastavena a nelze ji změnit.
• Výkon: Použití final může někdy zlepšit výkon, protože kompilátor může optimalizovat kód efektivněji, když ví, že proměnnou nebo metodu nelze změnit.
• Bezpečnostní: Finále může pomoci zlepšit zabezpečení tím, že zabrání škodlivému kódu v úpravě citlivých dat nebo chování.

Celkově je klíčové slovo final užitečným nástrojem pro zlepšení kvality kódu a zajištění toho, že určité aspekty programu nelze upravit nebo rozšířit. Deklarováním proměnných, metod a tříd za konečné mohou vývojáři psát bezpečnější, robustnější a udržovatelný kód.

Konečná proměnná Java

Když je proměnná deklarována s konečné klíčové slovo , své hodnotu nelze změnit v podstatě a konstantní . To také znamená, že vy musí inicializovat konečnou proměnnou .

Pokud je konečná proměnná a odkaz , to znamená, že proměnná nemůže být znovu vázán na odkaz jiný objekt, ale vnitřní stav objektu, na který odkazuje tato referenční proměnná, lze změnit, tj. můžete přidat nebo odebrat prvky z konečné pole nebo konečný odběr.

Je dobrým zvykem reprezentovat konečné proměnné velkými písmeny a k oddělení slov použít podtržítko.

Příklad:

public class ConstantExample {  public static void main(String[] args) {  // Define a constant variable PI  final double PI = 3.14159;  // Print the value of PI  System.out.println('Value of PI: ' + PI);  } }>

Value of PI: 3.14159>

Výstup:

  Value of PI: 3.14159>

Různé metody použití konečné proměnné

Podívejme se na různé metody, které můžeme použít jako finální proměnnou v Javě.

1. konečná Proměnná

Příklad:

// Final variable final int THRESHOLD = 5;>

2. Prázdná konečná proměnná

Příklad:

// Blank final variable final int THRESHOLD;>

3. Statická konečná proměnná

Příklad:

// Final static variable PI static final double PI = 3.141592653589793;>

4. Static Blank final Variable

Příklad:

// Blank final static variable static final double PI;>

Inicializace konečné proměnné

Musíme inicializovat konečnou proměnnou, jinak kompilátor vyvolá chybu při kompilaci. Konečnou proměnnou lze inicializovat pouze jednou, buď prostřednictvím an inicializátor nebo příkaz k zadání. Existují tři způsoby, jak inicializovat konečnou proměnnou:

středový obrázek v css

1. Konečnou proměnnou můžete inicializovat, když je deklarována. Tento přístup je nejběžnější. Poslední proměnná se nazývá a prázdná konečná proměnná Pokud to je ne inicializováno při deklaraci. Níže jsou uvedeny dva způsoby inicializace prázdné konečné proměnné.
2. Prázdná finální proměnná může být inicializována uvnitř blok instančního inicializátoru nebo konstruktér. Pokud máte ve své třídě více než jeden konstruktor, musí být inicializován ve všech, jinak bude vyvolána chyba při kompilaci.
3. Prázdnou konečnou statickou proměnnou lze inicializovat uvnitř a statický blok .

Podívejme se na tyto dva různé způsoby inicializace konečné proměnné

Příklad:

// Java Program to demonstrate Different // Ways of Initializing a final Variable // Main class  class GFG {    // a final variable  // direct initialize  final int THRESHOLD = 5;    // a blank final variable  final int CAPACITY;    // another blank final variable  final int MINIMUM;    // a final static variable PI  // direct initialize  static final double PI = 3.141592653589793;    // a blank final static variable  static final double EULERCONSTANT;    // instance initializer block for   // initializing CAPACITY  {  CAPACITY = 25;  }    // static initializer block for   // initializing EULERCONSTANT  static{  EULERCONSTANT = 2.3;  }    // constructor for initializing MINIMUM  // Note that if there are more than one  // constructor, you must initialize MINIMUM  // in them also  public GFG()   {  MINIMUM = -1;  }   }>

Ve výše uvedeném kódu nebyla žádná hlavní metoda, protože to bylo pouze pro ilustrační účely, aby bylo možné lépe porozumět a vyvodit závěry:

Pozorování 1: Kdy použít konečnou proměnnou?

Jediný rozdíl mezi normální proměnnou a konečnou proměnnou je v tom, že můžeme znovu přiřadit hodnotu normální proměnné, ale nemůžeme změnit hodnotu konečné proměnné, jakmile je jednou přiřazena. Konečné proměnné tedy musí být použity pouze pro hodnoty, které chceme, aby zůstaly konstantní po celou dobu provádění programu.

Pozorování 2: Referenční konečná proměnná.

Když je konečná proměnná odkazem na objekt, pak se tato konečná proměnná nazývá referenční konečná proměnná . Například finále StringBuffer proměnná vypadá níže definovaná takto:

final StringBuffer sb;>

Jak všichni víme, konečnou proměnnou nelze znovu přiřadit. Ale v případě referenční konečné proměnné lze vnitřní stav objektu, na který odkazuje tato referenční proměnná, změnit. Všimněte si, že se nejedná o opětovné přiřazení.

Tato vlastnost finále je nazýván netranzitivita . Chcete-li porozumět tomu, co se rozumí vnitřním stavem objektu, jak je znázorněno v následujícím příkladu:

Příklad 1:

// Java Program to demonstrate // Reference of Final Variable // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating an object of StringBuilder class  // Final reference variable  final StringBuilder sb = new StringBuilder('Geeks');  // Printing the element in StringBuilder object  System.out.println(sb);  // changing internal state of object reference by  // final reference variable sb  sb.append('ForGeeks');  // Again printing the element in StringBuilder  // object after appending above element in it  System.out.println(sb);  } }>

Geeks GeeksForGeeks>

The netranzitivita vlastnost platí také pro pole, protože pole jsou objekty v Javě. Pole s konečné klíčové slovo se také nazývají finální pole .

Poznámka: Jak bylo uvedeno výše, konečnou proměnnou nelze znovu přiřadit, způsobí to chybu při kompilaci.

Příklad 2:

konvence pojmenování java

// Java Program to Demonstrate Re-assigning // Final Variable will throw Compile-time Error // Main class class GFG {  // Declaring and customly initializing  // static final variable  static final int CAPACITY = 4;  // Main driver method  public static void main(String args[])  {  // Re-assigning final variable  // will throw compile-time error  CAPACITY = 5;  } }>

Výstup:

Pamatovat si: Když je konečná proměnná vytvořena uvnitř metody/konstruktoru/bloku, nazývá se lokální konečná proměnná a musí se inicializovat, jakmile je vytvořena. Viz níže uvedený program pro místní konečnou proměnnou.

Příklad:

// Java program to demonstrate // local final variable // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Declaring local final variable  final int i;  // Now initializing it with integer value  i = 20;  // Printing the value on console  System.out.println(i);  } }>

20>

Pamatujte si tyto klíčové body, jak je vnímáte, než se pohnete vpřed, jak je uvedeno níže:

1. Všimněte si rozdílu mezi C++ konst proměnné a Java finále proměnné. const proměnné v C++ musí být při deklaraci přiřazena hodnota . Pro konečné proměnné v Javě ano není nezbytné jak vidíme ve výše uvedených příkladech. Konečné proměnné lze přiřadit hodnotu později, ale pouze jednou.
2. finále s foreach smyčka : final s for-každé prohlášení je právní prohlášení.

Příklad:

// Java Program to demonstrate Final // with for-each Statement // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Declaring and initializing  // custom integer array  int arr[] = { 1, 2, 3 };  // final with for-each statement  // legal statement  for (final int i : arr)  System.out.print(i + ' ');  } }>

1 2 3>

Vysvětlení výstupu: Vzhledem k tomu, i proměnná jde mimo rozsah s každou iterací cyklu, je znovu deklarována při každé iteraci, což umožňuje použít stejný token (i) k reprezentaci více proměnných.

Příklad:

public class Example {  public static void main(String[] args) {  final int VALUE = 10; // declaring a final variable    System.out.println('The value is: ' + VALUE);  // VALUE = 20; // uncommenting this line will cause a compiler error  // System.out.println('The new value is: ' + VALUE);    final String MESSAGE = 'Hello, world!'; // declaring a final variable  System.out.println(MESSAGE);    MyClass myObj = new MyClass();  myObj.printMessage();  myObj.printFinalMessage();    // MyOtherClass extends MyClass {} // uncommenting this line will cause a compiler error  } } class MyClass {  final String message = 'Hello!'; // declaring a final instance variable    void printMessage() {  System.out.println(message);  }    void printFinalMessage() {  final String finalMessage = 'Hello, final!';  System.out.println(finalMessage);  } } final class MyOtherClass { // declaring a final class  // ... }>

The value is: 10 Hello, world! Hello! Hello, final!>

Java závěrečné třídy

Když je třída deklarována s finále klíčové slovo v Javě se nazývá a závěrečná třída . Závěrečná třída nemůže být rozšířený (zděděný) .

Konečná třída má dvě použití:

Použití 1: Jedním z nich je určitě zabránit dědictví , protože závěrečné třídy nelze prodloužit. Například všechny Třídy obalů jako Celé číslo , Plovák , atd. jsou závěrečné třídy. Nemůžeme je prodloužit.

final class A {  // methods and fields }   // The following class is illegal  class B extends A  {   // COMPILE-ERROR! Can't subclass A }>

Použití 2: Další použití final s třídami je to vytvořit neměnnou třídu jako předdefinované Tětiva třída. Třídu nelze učinit neměnnou, aniž by byla konečná.

Konečná metoda Java

Když je metoda deklarována pomocí finále klíčové slovo, nazývá se a konečná metoda v Javě. Konečná metoda nemůže být přepsáno .

The Objekt třída to dělá – řada jejích metod je konečných. Musíme deklarovat metody s klíčovým slovem final, pro které jsme povinni dodržovat stejnou implementaci ve všech odvozených třídách.

Ilustrace: Konečné klíčové slovo s metodou

class A  {  final void m1()   {  System.out.println('This is a final method.');  } } class B extends A  {  void m1()  {     // Compile-error! We can not override   System.out.println('Illegal!');  } }>

Výhody finálního klíčového slova v Javě:

Poslední klíčové slovo v Javě poskytuje několik výhod, včetně:

• Zajištění neměnnosti: Když je proměnná nebo reference označena jako konečná, nelze její hodnotu po přiřazení změnit. To pomáhá zajistit, že data jsou neměnná a nemohou být náhodně nebo úmyslně změněna.
• Zlepšení výkonu : Použití final může někdy pomoci zlepšit výkon, protože Java Virtual Machine (JVM) může optimalizovat kód efektivněji, když ví, že určité hodnoty nebo odkazy nelze změnit.
• Usnadnění pochopení kódu: Deklarováním proměnných, metod nebo tříd za konečné mohou vývojáři usnadnit jejich pochopení a uvažování. Když je hodnota nebo reference označena jako konečná, je jasné, že se nezmění, což může zjednodušit analýzu kódu a ladění.
• Propagace opětovného použití kódu: Prohlášením metod za konečné mohou vývojáři zabránit podtřídám v jejich přepsání. To může pomoci podpořit opětovné použití kódu a snížit duplicitu, protože podtřídy musí používat implementaci metody rodičovské třídy.
• Posílení zabezpečení: Použití final může pomoci zvýšit zabezpečení tím, že zabrání škodlivému kódu v úpravě citlivých dat nebo chování.

Celkově je klíčové slovo final užitečným nástrojem pro zlepšení kvality kódu a zajištění toho, že určité aspekty programu nelze upravit. Deklarováním proměnných, metod a tříd za konečné mohou vývojáři psát bezpečnější, robustnější a udržovatelný kód.

Další příklady a chování finálních metod a finálních tříd , prosím podívej se Použití konečné s dědictvím. Podívejte se prosím na abstrakt v Javě článek o rozdílech mezi finále a abstraktní .

Související otázka k rozhovoru (důležitá): Rozdíl mezi final, final a finalize v Javě

Závěr

Poslední klíčové slovo v Javě je metoda, jak vytvořit uživatelsky omezené proměnné, metody nebo třídy. V tomto tutoriálu se podrobně zabýváme posledním klíčovým slovem Java a rozumíme všem jeho souvislostem.

Kontexty jsou vysvětleny pomocí programů Java v příkladech, které poskytují úplné pochopení předmětu.

Java Final Keyword – FAQ

Co je konečná metoda v Javě?

Poslední metodou v Javě je metoda deklarovaná pomocí konečné klíčové slovo , což znamená, že jeho implementaci nelze přepsat podtřídami.

Je výsledná metoda zděděna?

Ne, v Javě nemůže být konečná metoda zděděna podtřídou. To znamená, že podtřída nemůže přepsat konečnou metodu .

Jaké je konečné klíčové slovo a statické klíčové slovo v Javě?

Konečné klíčové slovo: Používá se k deklaraci proměnných, metod nebo tříd jako nemodifikovatelných.

Statické klíčové slovo: Používá se k deklaraci členů třídy (proměnných a metod), které patří do třídy samotné, nikoli jednotlivých objektů.

Můžeme napsat konečné klíčové slovo s řetězcem v Javě?

Ano, můžete deklarovat proměnnou s klíčovým slovem final a přiřadit k ní řetězcový literál.