この投稿では、Java の別の Final キーワードを見ていきます。 Java 言語で、他のクラスや変数による使用や変更に制限を適用するために使用されるキーワードです。このキーワードを使用すると、その変数またはメソッドに対する将来の変更を許可せず、それを定数として扱うようにインタプリタに指示します。以下の 3 つのシナリオで使用できます:-
広告 このカテゴリーの人気コース 財務モデリングと評価 - 専門分野 | 51 コースシリーズ | 30 回の模擬テスト無料ソフトウェア開発コースを始めましょう
Web 開発、プログラミング言語、ソフトウェア テスト、その他
適切なコーディング慣行に従って、これらのキーワードは常に大文字で宣言することが推奨されます。
このキーワードは以下の 3 つの方法で使用できます:-
Java の変数は、その値の変更を制限する変数として宣言できます。以下の 3 つの方法のいずれかで宣言できます -
構文:
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”);
final キーワードで宣言されたメソッドは、final メソッドと言われます。 Final メソッドはその子クラスによってオーバーライドできません。つまり、子クラスのメソッドは親クラスに存在する Final メソッドの定義を変更できません。親クラスで定義されたメソッドの実装がすべての子クラスでも従う必要がある場合、そのメソッドをfinalとして宣言する必要があります。
構文:
final int my1(){
//method defination
}final キーワードをクラスで使用して、それを最終クラスにすることもできます。つまり、特定のクラスを他のクラスで拡張したり継承したりすることはできません。
構文:
final class myClass{
/member variables and member functions.
}final キーワードは、継承時のクラス、メンバー、または変数のオーバーライドを制限するのに役立ちます。
変数をfinalとして宣言すると、継承されたクラス内の変数の値への変更が制限されます。最終変数は 1 回だけ初期化できるため、そのまま使用する必要があります。したがって、最終変数を初期化する必要があります。これは主に、定数クラス変数を作成するために static とともに使用されます。
例:
final int a =0;
参照変数を Final として宣言することもできます。この場合、1 つの参照変数が異なるオブジェクトを参照することはできません。しかし、Java では、オブジェクトの内部状態を変更できます。最後の参照変数はそれを参照します。したがって、参照変数の値を変更できます。これは、以下に示す最終配列を使用するのと同じです:-
コード:
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]);
}
}
}出力:
説明
ここで、配列 a1 は同じオブジェクトを参照します。配列変数には、配列の要素が格納されているメモリ位置の開始アドレスだけが含まれていることは誰もが知っているため、そのオブジェクトの値のみが変化します。
同様に、同じ配列変数 a1 を使用して別の配列を参照しようとすると、コンパイラはエラーをスローします。したがって、ここで word-final 配列を使用すると、配列メンバーに任意の変更を加えることができますが、変数が他のオブジェクトを参照することは許可されないことを意味します。
覚えておくべきこと
コンパイル時のエラーを防ぐために、最終変数の初期化が必要です。 C++ の const 変数とこれらの最終変数との間には、const 変数を初期化する必要がないという違いがあります。最終変数を初期化するには 3 つの方法があります -
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.
以上がJava の最後のキーワードの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
