Java: modificador de acceso final vs estático

La palabra clave final se usa en diferentes contextos. En primer lugar, final es un modificador de no acceso aplicable solo a una variable, un método o una clase. Los siguientes son diferentes contextos donde se usa final. Mientras que la palabra clave estática en Java se utiliza principalmente para la gestión de la memoria. La palabra clave estática en Java se usa para compartir la misma variable o método de una clase determinada. Los usuarios pueden aplicar palabras clave estáticas con variables, métodos, bloques y clases anidadas.

Modificador de acceso final

Modificador de acceso finales un modificador aplicable a clases, métodos y variables. Si declaramos un método de clase principal como final, no podemos anular ese método en la clase secundaria porque su implementación es final y si una clase se declara como final, no podemos extender la funcionalidad de esa clase, es decir, no podemos crear una clase secundaria para esa clase, es decir, la herencia no es posible para las clases finales. Cada método presente dentro de la clase final es siempre final y predeterminado, pero no es necesario que cada variable presente dentro de la clase final sea final. La principal ventaja de la palabra clave final es que podemos lograr seguridad y podemos proporcionar una implementación única. Pero la principal desventaja de la palabra clave final es que nos faltan beneficios clave de los OOP como la herencia (debido a la clase final),

Ejemplo 1:

// Java Program to illustrate Final keyword
// Where No final keyword Is Used
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Super-class
class P {
 
    // Method 1
    // To declare first name
    public void firstName()
    {
 
        // Passing name and print it
        System.out.println("Mayank");
    }
 
    // Method 2
    // To declare last name
    public void surName()
    {
 
        // Passing name and print it
        System.out.println("Trivedi");
    }
}
 
// Class 2
// Sub-class
// Extending above class
class C extends P {
 
    // Method 1
    // Trying to override the last name
    public void surName()
    {
        // Display surname
        System.out.println("Sharma");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Display message
        System.out.println("GFG");
    }
}

GFG

Ejemplo 2:

// Java Program to illustrate Final keyword
// When final keyword Is Used
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Super-class
class P {
 
    // Method 1
    // To declare first name
    public void firstName()
    {
 
        // Passing name and print it
        System.out.println("Mayank");
    }
 
    // Method 2
    // To declare last name
    public final void surName()
    {
 
        // Passing name and print it
        System.out.println("Trivedi");
    }
}
 
// Class 2
// Sub-class
// Extending above class
class C extends P {
 
    // Method 1
    // Trying to override the last name
    public void surName()
    {
        // Display surname
        System.out.println("Sharma");
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
 
        // Display message
        System.out.println("GFG");
    }
}

Producción:

Modificador de acceso estático

El modificador de acceso estático es un modificador de acceso que se aplica a métodos y variables, pero no a clases. Podemos declarar la clase de nivel superior con un modificador estático pero podemos declarar la clase interna como estática (este tipo de clases internas se conocen como clases anidadas estáticas). En el caso de una variable de instancia para cada objeto, se creará una copia separada, pero en el caso de una variable estática, se creará una única copia a nivel de clase y será compartida por cada objeto de esa clase.

Ejemplo

// Java Program to Illustrate Static Access Modifier
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Main class
class GFG {
 
    // Creating a static variable and
    // initializing a custom value
    static int x = 10;
 
    // Creating a instance variable and
    // initializing a custom value
    int y = 20;
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an object of class inside main() method
        GFG t1 = new GFG();
 
        // Accessing and re-initializing the
        // static and instance variable
        // using t1 reference
        t1.x = 88;
        t1.y = 99;
 
        // Creating an object of class inside main() method
        // again
        GFG t2 = new GFG();
 
        // Accessing the static and instance variable using
        // t2 reference as we know that for each object
        // there is a separate copy of instance variable
        // created. While a same copy of static variable will
        // be shared between the objects
 
        // Displaying the value of static and instance
        // variable using t2 object reference
        System.out.println(
            "Value of Static variable x = " + t2.x + "\n"
            + "Value of Instance variable y = " + t2.y);
    }
}

Value of Static variable x = 88
Value of Instance variable y = 20

Después de tener una buena comprensión e implementación de los dos especificadores anteriores y estas importantes palabras clave especiales, tabulemos las diferencias entre ellos para comprender bien estas palabras clave.