java final与继承_在Java中使用final进行继承

Java 面向对象/Java 继承

在Java中使用final进行继承

final是用于限制某些功能的java中的一个关键字。我们可以用final关键字声明变量，方法和类。

使用final来继承

在继承期间，我们必须声明带有final关键字的方法，以便在所有派生类中遵循相同的实现。请注意，没有必要在继承的初始阶段声明最终方法(基类始终)。我们可以在任何我们想要的子类中声明final方法，如果任何其他类扩展了这个子类，那么它必须遵循与该子类相同的方法实现。

// 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 cann'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 finalso any class extending

// Rectangle cann't override it

@Override

final double getArea()

{

return this.getHeight() * this.getWidth();

}

}

//derived class two

class Square extends Shape

{

// Rectangle 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 cann'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());

}

}

输出：

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

使用final来防止继承

当一个类被声明为final时，它不能被继承，即没有其他类可以扩展它。这是特别有用的，例如，当创建一个像预定义的String类这样的不可变类时。以下片段用类说明final关键字：

final class A

{

// methods and fields

}

// The following class is illegal.

class B extends A

{

// ERROR! Can't subclass A

}

注意 ：

声明一个类最终隐含地声明它的所有方法也是最终的。

它是非法的声明一个类既是抽象的，并最终因为一个抽象类是本身不完整的，在它的子类依靠提供完整的实现。

使用final来防止覆盖

当一个方法被声明为最终的时候，它不能被子类覆盖。对象object类这样做 - 它的一些方法是最终的。以下片段用方法说明了final关键字：

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!");

}

}

通常，Java在运行时动态地解析对方法的调用。这被称为晚期或动态绑定。但是，由于最终方法不能被覆盖，所以可以在编译时解决对方法的调用。这被称为早期或静态绑定。