The galīgā metode Java tiek izmantots kā a nepiekļuves modifikators attiecas tikai uz a mainīgs , a metodi , vai a klasē. Tā ir pieradusi ierobežot lietotāju Java valodā .

Tālāk ir norādīti dažādos kontekstos kur tiek izmantots fināls:

1. Mainīgs
2. Metode
3. Klase

Java gala atslēgvārda īpašības:

Java valodā pēdējais atslēgvārds tiek izmantots, lai norādītu, ka mainīgo, metodi vai klasi nevar mainīt vai paplašināt. Šeit ir dažas no tās īpašībām:

• Galīgie mainīgie: Ja mainīgais ir deklarēts kā galīgs, tā vērtību nevar mainīt, kad tas ir inicializēts. Tas ir noderīgi, lai deklarētu konstantes vai citas vērtības, kuras nevajadzētu mainīt.
• Galīgās metodes : ja metode ir deklarēta kā galīga, to nevar ignorēt apakšklase. Tas ir noderīgi metodēm, kas ir daļa no klases publiskā API, un tās nedrīkst mainīt apakšklasēs.
• Noslēguma nodarbības: Kad klase tiek pasludināta par galīgu, to nevar paplašināt ar apakšklasi. Tas ir noderīgi klasēm, kuras paredzēts izmantot tādas, kādas tās ir, un kuras nevajadzētu mainīt vai paplašināt.
• Inicializācija: Galīgie mainīgie ir jāinicializē vai nu deklarēšanas laikā, vai klases konstruktorā. Tas nodrošina, ka mainīgā vērtība ir iestatīta un to nevar mainīt.
• Veiktspēja: Fināla izmantošana dažkārt var uzlabot veiktspēju, jo kompilators var efektīvāk optimizēt kodu, ja zina, ka mainīgo vai metodi nevar mainīt.
• Drošība: Pēdējā var palīdzēt uzlabot drošību, neļaujot ļaunprātīgam kodam mainīt sensitīvus datus vai uzvedību.

Kopumā pēdējais atslēgvārds ir noderīgs rīks, lai uzlabotu koda kvalitāti un nodrošinātu, ka noteiktus programmas aspektus nevar mainīt vai paplašināt. Pasludinot mainīgos, metodes un klases kā galīgus, izstrādātāji var rakstīt drošāku, izturīgāku un uzturējamāku kodu.

Java galīgais mainīgais

Kad mainīgais tiek deklarēts ar pēdējais atslēgvārds , tā vērtību nevar mainīt , būtībā, a nemainīgs . Tas arī nozīmē, ka jūs ir jāinicializē pēdējais mainīgais .

Ja pēdējais mainīgais ir a atsauce , tas nozīmē, ka mainīgais nevar būt atkārtoti piesaistīta atsaucei citu objektu, bet objekta iekšējo stāvokli, uz kuru norāda šis atsauces mainīgais, var mainīt, t.i., varat pievienot vai noņemt elementus no gala masīvs vai galīgā kolekcija.

Ir laba prakse pēdējos mainīgos attēlot ar visiem lielajiem burtiem, vārdu atdalīšanai izmantojot pasvītrojumu.

Piemērs:

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>

Izvade:

  Value of PI: 3.14159>

Dažādas galīgā mainīgā izmantošanas metodes

Apskatīsim dažādas metodes, kuras varam izmantot Java galīgo mainīgo.

1. gala Mainīgais

Piemērs:

// Final variable final int THRESHOLD = 5;>

2. Tukšs gala mainīgais

Piemērs:

// Blank final variable final int THRESHOLD;>

3. Statiskais galīgais mainīgais

Piemērs:

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

4. Statiskais tukšais galīgais mainīgais

Piemērs:

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

Pēdējā mainīgā inicializācija

Mums ir jāinicializē pēdējais mainīgais, pretējā gadījumā kompilators radīs kompilēšanas laika kļūdu. Galīgo mainīgo var inicializēt tikai vienu reizi, izmantojot vai nu inicializators vai uzdevuma paziņojums. Ir trīs veidi, kā inicializēt galīgo mainīgo:

plsql

1. Jūs varat inicializēt galīgo mainīgo, kad tas ir deklarēts. Šī pieeja ir visizplatītākā. Galīgo mainīgo sauc par a tukšs gala mainīgais ja tas ir nē inicializēts deklarēšanas laikā. Tālāk ir norādīti divi veidi, kā inicializēt tukšu galīgo mainīgo.
2. Tukšu galīgo mainīgo var inicializēt iekšpusē instances inicializatora bloks vai konstruktors. Ja jūsu klasē ir vairāk nekā viens konstruktors, tas ir jāinicializē visos, pretējā gadījumā tiks parādīta kompilēšanas laika kļūda.
3. Tukšu galīgo statisko mainīgo var inicializēt a iekšpusē statisks bloks .

Apskatīsim šos divus dažādos galīgā mainīgā inicializācijas veidus

Piemērs:

// 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;  }   }>

Iepriekš minētajā kodā nebija galvenās metodes, jo tā bija tikai ilustrācijas nolūkos, lai iegūtu labāku izpratni un izdarītu secinājumus:

1. novērojums: Kad izmantot galīgo mainīgo?

Vienīgā atšķirība starp parasto mainīgo un galīgo mainīgo ir tā, ka mēs varam atkārtoti piešķirt vērtību parastajam mainīgajam, bet mēs nevaram mainīt galīgā mainīgā vērtību, kad tas ir piešķirts. Tādējādi galīgie mainīgie ir jāizmanto tikai tām vērtībām, kuras vēlamies palikt nemainīgas visā programmas izpildes laikā.

2. novērojums: Atsauces gala mainīgais.

Ja pēdējais mainīgais ir atsauce uz objektu, tad šo pēdējo mainīgo sauc par atsauces gala mainīgais . Piemēram, fināls StringBuffer Mainīgais izskatās definēts šādi:

final StringBuffer sb;>

Kā mēs visi zinām, galīgo mainīgo nevar piešķirt atkārtoti. Bet atsauces gala mainīgā gadījumā var mainīt objekta iekšējo stāvokli, uz kuru norāda šis atsauces mainīgais. Ņemiet vērā, ka šī nav atkārtota piešķiršana.

Šis īpašums galīgais tiek saukts netransitivitāte . Lai saprastu, ko nozīmē objekta iekšējais stāvoklis, kā parādīts zemāk esošajā piemērā, šādi:

1. piemērs:

// 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 netransitivitāte īpašums attiecas arī uz masīviem, jo masīvi ir objekti Java valodā. Masīvi ar pēdējais atslēgvārds tiek saukti arī galīgie masīvi .

Piezīme: Kā minēts iepriekš, galīgo mainīgo nevar atkārtoti piešķirt, jo to darot, tiks parādīta kompilēšanas laika kļūda.

2. piemērs:

// 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;  } }>

Izvade:

Atcerieties: Kad metodē/konstruktorā/blokā tiek izveidots galīgais mainīgais, to sauc par vietējo galīgo mainīgo, un tas vienreiz jāinicializē vietā, kur tas ir izveidots. Vietējo galīgo mainīgo skatīt zemāk.

Piemērs:

java vs c++

// 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>

Pirms turpināt, atcerieties šos galvenos punktus, kā norādīts tālāk:

1. Ņemiet vērā atšķirību starp C++ konst mainīgie un Java galīgais mainīgie. const mainīgajiem C++ ir jābūt tiek piešķirta vērtība, kad tā tiek deklarēta . Java pēdējiem mainīgajiem tā ir nav nepieciešams kā redzam iepriekš minētajos piemēros. Galīgajam mainīgajam vērtību var piešķirt vēlāk, bet tikai vienu reizi.
2. galīgais ar foreach cilpa : gala ar katru paziņojumu ir juridisks paziņojums.

Piemērs:

// 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>

Izvades skaidrojums: Kopš i mainīgais iziet ārpus darbības jomas ar katru cilpas iterāciju, tas tiek atkārtoti deklarēts katrā iterācijā, ļaujot izmantot to pašu marķieri (i), lai attēlotu vairākus mainīgos.

Piemērs:

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 nobeiguma nodarbības

Kad klase ir deklarēta ar galīgais Java valodā to sauc par a noslēguma klase . Pēdējā klase nevar būt pagarināts (mantots) .

Ir divi gala klases lietojumi:

1. lietojums: Viens noteikti ir novērst mantojums , jo pēdējās nodarbības nevar pagarināt. Piemēram, visas Iesaiņojuma klases patīk Vesels skaitlis , Pludiņš uc ir noslēguma nodarbības. Mēs nevaram tos pagarināt.

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

2. lietojums: Otrs gala ar klasēm lietojums ir izveidot nemainīgu klasi tāpat kā iepriekš definētais Stīga klasē. Nevar padarīt klasi nemainīgu, ja tā nav galīga.

Java galīgā metode

Kad metode ir deklarēta ar galīgais atslēgvārdu, to sauc par a galīgā metode Java valodā. Galīgā metode nevar būt ignorēts .

The Objekts klase to dara — vairākas tās metodes ir galīgas. Mums ir jādeklarē metodes ar pēdējo atslēgvārdu, kurām mums ir jāievēro viena un tā pati ieviešana visās atvasinātajās klasēs.

Ilustrācija: Pēdējais atslēgvārds ar metodi

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!');  } }>

Galīgā atslēgvārda priekšrocības Java valodā:

Pēdējais Java atslēgvārds sniedz vairākas priekšrocības, tostarp:

• Nemainības nodrošināšana: Ja mainīgais vai atsauce ir atzīmēta kā galīga, tā vērtību nevar mainīt pēc tā piešķiršanas. Tas palīdz nodrošināt, ka dati ir nemainīgi un tos nevar nejauši vai ļaunprātīgi pārveidot.
• Veiktspējas uzlabošana : Fināla izmantošana dažkārt var palīdzēt uzlabot veiktspēju, jo Java virtuālā mašīna (JVM) var efektīvāk optimizēt kodu, ja tā zina, ka noteiktas vērtības vai atsauces nevar mainīt.
• Lai padarītu kodu vieglāk saprotamu: Pasludinot mainīgos, metodes vai klases kā galīgus, izstrādātāji var padarīt savu kodu vieglāk saprotamu un pamatotu. Kad vērtība vai atsauce ir atzīmēta kā galīga, ir skaidrs, ka tā nemainīsies, kas var vienkāršot koda analīzi un atkļūdošanu.
• Kodu atkārtotas izmantošanas veicināšana: Pasludinot metodes kā galīgas, izstrādātāji var novērst to, ka apakšklases tās ignorē. Tas var palīdzēt veicināt koda atkārtotu izmantošanu un samazināt dublēšanos, jo apakšklasēm ir jāizmanto vecākklases metodes ieviešana.
• Drošības uzlabošana: Fināla izmantošana var palīdzēt uzlabot drošību, neļaujot ļaunprātīgam kodam mainīt sensitīvus datus vai uzvedību.

Kopumā pēdējais atslēgvārds ir noderīgs rīks, lai uzlabotu koda kvalitāti un nodrošinātu, ka noteiktus programmas aspektus nevar mainīt. Pasludinot mainīgos, metodes un klases kā galīgus, izstrādātāji var rakstīt drošāku, izturīgāku un uzturējamāku kodu.

Lai iegūtu vairāk piemēru un galīgo metožu un galīgo klašu uzvedību , Lūdzu apskati Izmantojot galīgo ar mantojumu. Lūdzu, skatiet abstrakts java rakstu par atšķirībām starp galīgais un abstrakts .

Saistīts intervijas jautājums (svarīgi): Atšķirība starp galīgo, galīgo un galīgo versiju Java

Secinājums

Pēdējais Java atslēgvārds ir metode, kā izveidot lietotāja ierobežotus mainīgos, metodes vai klases. Šajā apmācībā mēs detalizēti aplūkojam Java pēdējo atslēgvārdu un izprotam visus tā kontekstus.

Konteksti ir izskaidroti ar Java programmām piemēros, nodrošinot pilnīgu izpratni par tēmu.

Java galīgais atslēgvārds — FAQ

Kas ir Java galīgā metode?

Pēdējā Java metode ir metode, kas deklarēta ar pēdējais atslēgvārds , kas nozīmē, ka tās ieviešanu nevar ignorēt apakšklases.

Vai galīgā metode ir iedzimta?

Nē, Java galīgo metodi nevar mantot apakšklase. Tas nozīmē, ka apakšklase nevar ignorēt pēdējo metodi .

Kāds ir pēdējais atslēgvārds un statiskais atslēgvārds Java?

Pēdējais atslēgvārds: To izmanto, lai deklarētu mainīgos, metodes vai klases kā nemodificētus.

Statisks atslēgvārds: to izmanto, lai deklarētu klases dalībniekus (mainīgos un metodes), kas pieder pašai klasei, nevis atsevišķiem objektiem.

Vai Java mēs varam ierakstīt galīgo atslēgvārdu ar virkni?

Jā, jūs varat deklarēt mainīgo ar galīgo atslēgvārdu un piešķirt tam virkni literāru.