Rumah >Java >javaTutorial >Kata Kunci Akhir dalam Java
Dalam siaran ini, kita akan melihat kata kunci akhir yang berbeza untuk java. Ia adalah kata kunci yang digunakan dalam bahasa java untuk menggunakan sekatan pada penggunaannya atau pengubahsuaian oleh kelas atau pembolehubah lain. Menggunakan kata kunci ini, seseorang memberitahu penterjemah untuk tidak membenarkan sebarang pengubahsuaian masa depan pada pembolehubah atau kaedah itu dan menganggapnya sebagai malar. Ia boleh digunakan dengan 3 senario di bawah:-
IKLAN Kursus Popular dalam kategori ini PEMODELAN & PENILAIAN KEWANGAN - Pengkhususan | 51 Siri Kursus | 30 Ujian Olok-olokMulakan Kursus Pembangunan Perisian Percuma Anda
Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain
Menurut amalan pengekodan yang baik, kata kunci ini sentiasa disyorkan untuk diisytiharkan dalam huruf besar.
Kata kunci ini boleh digunakan dalam 3 cara di bawah:-
Pembolehubah dalam java boleh diisytiharkan sebagai pembolehubah untuk menyekat sebarang perubahan pada nilainya. Ia boleh diisytiharkan dalam mana-mana satu daripada tiga cara di bawah-
Sintaks:
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 variableNota- Pembolehubah rujukan juga boleh diisytiharkan statik supaya ia tidak boleh memegang rujukan kepada objek lain. Tetapi disebabkan sifat dalaman objek, rujukan boleh diubah.
pembina String akhir sb= StringBuilder baharu(“Mari Belajar”);
Kaedah yang diisytiharkan dengan kata kunci akhir dikatakan kaedah terakhir. Kaedah akhir tidak boleh ditindih oleh kelas anaknya, yang bermaksud kaedah kelas anak tidak boleh mengubah takrif kaedah akhir yang terdapat dalam kelas induk. Apabila kita mahu pelaksanaan kaedah yang ditakrifkan dalam kelas induk mesti diikuti dalam semua kelas kanak-kanak, kita mesti mengisytiharkan kaedah itu sebagai muktamad.
Sintaks:
final int my1(){ //method defination }
Kata kunci akhir juga boleh digunakan dengan kelas untuk menjadikannya kelas akhir, bermakna kelas tertentu tidak boleh dilanjutkan atau diwarisi oleh mana-mana kelas lain.
Sintaks:
final class myClass{ /member variables and member functions. }
Kata kunci terakhir membantu mengehadkan penggantian kelas, ahli atau pembolehubah semasa pewarisan.
Mengisytiharkan pembolehubah sebagai muktamad bermakna mengehadkan sebarang perubahan kepada nilai pembolehubah dalam kelas yang diwarisi. Pembolehubah akhir hanya boleh dimulakan sekali dan mesti digunakan sebagaimana adanya; oleh itu, seseorang mesti memulakan pembolehubah akhir. Ia kebanyakannya digunakan dengan statik untuk mencipta pembolehubah kelas malar.
Sebagai Contoh:
final int a =0;
Kami juga boleh mengisytiharkan pembolehubah rujukan muktamad juga; dalam kes ini, satu pembolehubah rujukan tidak boleh merujuk kepada objek yang berbeza. Tetapi dalam java, keadaan dalaman objek boleh diubah; pembolehubah rujukan akhir merujuk kepada itu. Oleh itu kita boleh membuat perubahan kepada nilai pembolehubah rujukan. Ini adalah sama seperti menggunakan tatasusunan akhir seperti yang ditunjukkan di bawah:-
Kod:
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]); } } }
Output:
Penjelasan
Di sini, tatasusunan a1 merujuk kepada objek yang sama; hanya nilai objek itu yang berubah kerana kita semua tahu bahawa pembolehubah tatasusunan mengandungi hanya alamat permulaan lokasi memori tempat unsur tatasusunan tersebut disimpan.
Dan dalam perkara yang sama, jika kita cuba merujuk kepada tatasusunan yang berbeza menggunakan pembolehubah tatasusunan yang sama a1, maka pengkompil akan membuang ralat. Oleh itu, menggunakan tatasusunan akhir kata di sini bermakna sebarang pengubahan boleh dibuat kepada ahli tatasusunan, tetapi pembolehubah tidak dibenarkan merujuk kepada mana-mana objek lain.
Perkara yang Perlu Diingat
Memulakan pembolehubah akhir adalah perlu untuk mengelakkan ralat masa kompilasi. Terdapat perbezaan antara pembolehubah const C++ dan pembolehubah akhir ini yang pembolehubah const tidak perlu dimulakan. Terdapat tiga cara untuk memulakan pembolehubah akhir-
Thus, the final keyword is used for those variables that need not change their value during the program’s execution. All the final variables created inside a method or block must be initialized there itself. Such type of variables is known as local final variables.
Explanation
In the below example, a variable I has been declared within the main function and initialised is considered a final local variable.
Code:
class myClass { public static void main(String args[]) { // local final variable final int i; i = 20; System.out.println(i); } }
Output:
A method declared as final can not be overridden in any of the subclasses, thus called a final method. The method needs to be declared as final if we require that the child classes follow the class’s same implementation.
Note- Final methods don’t need to be declared in the initial stage of inheritance(base class ). The method can be declared final in any subclass that we want further subclasses to follow the same definition.Code:
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 } }
Classes declared as final can not be inherited by any other classes. Mentioning a final keyword before the class name tells the compiler that this class’s definition can only be used as they are. No other classes can add their specifications to this definition or reuse its code. If one attempts to extend the final class, an error is thrown by the compiler indicating that this class is not meant to be extended. One can use final keywords in java in any for below 2 purposes:-
final class myParentClass { // member variables and member functions } // illegal extend. class myChildClass extends parentClass { // <--COMPILE-ERROR—> Can't subclass A }
Note-
Below is the Different Example of Final Keyword in Java are:
In the below example, different variables are initialized using various methods. For example- the SECOND variable is initialized using a constructor, whereas THIRD is initialized using an initializer.
Code:
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 } }
Output:
In the below example, abstract class myShape declares final methods getWidth and get eight those need not be overridden by the inherited classes. It also declares one abstract function whose implementation is mandatory in the subsequent classes. Thus the only the definition of an abstract function is implemented in a first child class and a second child class.
Code:
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()); } }
Output:
In the below program, we are using a final class Solid that defines a method to calculate the volume of a shape using its dimensions, but displaying the volume of a box is done using the inherited class’s printVol function. Shape As Solid is a final class; thus, class Shape will not be allowed to extend(or inherit) it. Thus, it uses Shape’s object to calculate the volume of any of Shape by just passing the arguments to the functions.
Code:
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); } }
Output:
The final keyword is used to prevent the classes, variables, and methods to be overridden by its child classes. It can also be used to make classes immutable that is restricting the change in the value of their objects. The final keyword check is always checked at the compile time only. It is a great utility to prevent the reuse of the defined variables, logic, and classes.
Atas ialah kandungan terperinci Kata Kunci Akhir dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!