Usando final con Herencia en Java

Requisito previo: reemplazando en Java , Inheritance  
final es una palabra clave en Java que se usa para restringir algunas funcionalidades. Podemos declarar variables, métodos y clases con la palabra clave final. 
 

Usando final con herencia

Durante la herencia, debemos declarar métodos con la palabra clave final para lo cual debemos seguir la misma implementación en todas las clases derivadas. Tenga en cuenta que no es necesario declarar métodos finales en la etapa inicial de herencia (clase base siempre). Podemos declarar un método final en cualquier subclase para el que queramos que si cualquier otra clase extiende esta subclase, entonces debe seguir la misma implementación del método que en esa subclase.
 

// Java program to illustrate
// use of final with inheritance
 
// base class
abstract class Shape
{
    private double width;
     
    private double height;
     
    // Shape class parameterized constructor
    public Shape(double width, double height)
    {
        this.width = width;
        this.height = height;
    }
     
    // getWidth method is declared as final
    // so any class extending
    // Shape can't override it
    public final double getWidth()
    {
        return width;
    }
     
    // getHeight method is declared as final
    // so any class extending Shape
    // can not override it
    public final double getHeight()
    {
        return height;
    }
 
 
    // method getArea() declared abstract because
    // it upon its subclasses to provide
    // complete implementation
    abstract double getArea();
}
 
// derived class one
class Rectangle extends Shape
{
    // Rectangle class parameterized constructor
    public Rectangle(double width, double height)
    {
        // calling Shape class constructor
        super(width, height);
    }
 
    // getArea method is overridden and declared
    // as final    so any class extending
    // Rectangle can't override it
    @Override
    final double getArea()
    {
        return this.getHeight() * this.getWidth();
    }
     
}
 
//derived class two
class Square extends Shape
{
    // Square class parameterized constructor
    public Square(double side)
    {
        // calling Shape class constructor
        super(side, side);
    }
 
    // getArea method is overridden and declared as
    // final so any class extending
    // Square can't override it
    @Override
    final double getArea()
    {
        return this.getHeight() * this.getWidth();
    }
     
}
 
// Driver class
public class Test
{
    public static void main(String[] args)
    {
        // creating Rectangle object
        Shape s1 = new Rectangle(10, 20);
         
        // creating Square object
        Shape s2 = new Square(10);
         
        // getting width and height of s1
        System.out.println("width of s1 : "+ s1.getWidth());
        System.out.println("height of s1 : "+ s1.getHeight());
         
        // getting width and height of s2
        System.out.println("width of s2 : "+ s2.getWidth());
        System.out.println("height of s2 : "+ s2.getHeight());
         
        //getting area of s1
        System.out.println("area of s1 : "+ s1.getArea());
         
        //getting area of s2
        System.out.println("area of s2 : "+ s2.getArea());
         
    }
}

Producción: 
 

width of s1 : 10.0
height of s1 : 20.0
width of s2 : 10.0
height of s2 : 10.0
area of s1 : 200.0
area of s2 : 100.0

Uso de final para evitar la herencia

Cuando una clase se declara como final, no se puede subclasificar, es decir, ninguna otra clase puede ampliarla. Esto es particularmente útil, por ejemplo, al crear una clase inmutable como la clase String predefinida . El siguiente fragmento ilustra la palabra clave final con una clase:
 

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

Nota : 
 

• Declarar una clase como final también declara implícitamente todos sus métodos como finales.
• Es ilegal declarar una clase tanto abstracta como final , ya que una clase abstracta está incompleta por sí misma y depende de sus subclases para proporcionar implementaciones completas. Para obtener más información sobre clases abstractas, consulte clases abstractas en Java

Uso de final para evitar la anulación

Cuando un método se declara como final, las subclases no pueden anularlo. La clase Object hace esto: varios de sus métodos son definitivos. El siguiente fragmento ilustra la palabra clave final con un método: 
 

class A 
{
    final void m1() 
    {
        System.out.println("This is a final method.");
    }
}

class B extends A 
{
    void m1()
    { 
        // ERROR! Can't override.
        System.out.println("Illegal!");
    }
}

Normalmente, Java resuelve las llamadas a los métodos de forma dinámica, en tiempo de ejecución. Esto se denomina vinculación tardía o dinámica . Sin embargo, dado que los métodos finales no se pueden anular, una llamada a uno se puede resolver en tiempo de compilación. Esto se denomina vinculación anticipada o estática . 
Este artículo es una contribución de Gaurav Miglani . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.