Modificador de no acceso final vs estático vs abstracto

Los modificadores son palabras clave específicas presentes en Java con las que podemos realizar cambios en las características de una variable, método o clase y limitar su alcance. El lenguaje de programación Java tiene un rico conjunto de modificadores. Los modificadores en Java se dividen en dos tipos

1. Modificadores de acceso
2. Modificadores de no acceso

Los modificadores de no acceso proporcionan información sobre las características de una clase, método o variable a la JVM. Hay siete tipos de modificadores de no acceso presentes en Java. Están

• estático
• final
• resumen
• sincronizado
• volátil
• transitorio
• nativo

Obtenga más información sobre los modificadores de no acceso en Java . En este artículo, vamos a discutir las diferencias entre los modificadores de no acceso finales, estáticos y abstractos. 

Modificador final de no acceso

El modificador final de no acceso es 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");
    }
}

Producción:

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 estático de no acceso

El modificador estático de no acceso se aplica a métodos y variables, pero no a clases. Podemos declarar una 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 = 888;
        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 separate copy of instance variable
        // created. While 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);
    }
}

Producción:

Modificador abstracto de no acceso

El modificador abstracto de no acceso es aplicable solo para clases y métodos, pero no para variables. Si declaramos cualquier método como abstracto, ese método debe tener su implementación en la clase secundaria de la clase respectiva porque los métodos abstractos nunca hablan de implementación. Si algún modificador habla de implementación, forma una combinación ilegal con un modificador abstracto. De manera similar, si para cualquier clase de Java no se nos permite crear un objeto (debido a una implementación parcial), entonces ese tipo de clase debemos declararlo con un modificador abstracto.

Ejemplo:

// Java program to illustrate Abstract Access Modifier
  
// Importing the required packages
import java.io.*;
import java.util.*;
  
// Class 1
// Helper abstract class
abstract class Vehicle {
  
    // Declaring an abstract method getNumberOfWheel
    abstract public int getNumberOfWheel();
}
  
// Class 2
// Helper class extending above abstract class
class Bus extends Vehicle {
  
    // Giving the implementation
    // to the  parent abstract method
    public int getNumberOfWheel() { return 7; }
}
  
// Class 3
// Helper class extending above abstract class
class Auto extends Vehicle {
  
    // Giving the implementation
    // to the  parent abstract method
    public int getNumberOfWheel() { return 3; }
}
  
// Class 4
// Main class
public class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating Bus object
        Bus b = new Bus();
  
        // Creating Auto object
        Auto a = new Auto();
  
        // Now getting and displaying
        // the number of wheels
        // for Bus by calling the
        // getNumberOfWheel method
        System.out.println("Number of wheels in bus is"
                           + " " + b.getNumberOfWheel());
  
        // Now getting and displaying
        // the number of wheels
        // for Auto by calling the
        // getNumberOfWheel method
        System.out.println("Number of wheels in Auto is"
                           + " " + a.getNumberOfWheel());
    }
}

Producción:

Tabla de diferencias