java中的抽象关键字-yiteyi-C++库

摘要 java中的非访问修饰符是否适用于类、方法，但不变量。它用于实现抽象，抽象是面向对象编程（OOP）的支柱之一。以下是不同的语境摘要可以在Java中使用。

null

具有部分实现的类（即，类中存在的并非所有方法都具有方法定义）。要声明类摘要，请使用以下一般形式：

abstract class class-name{    //body of class}

由于它们的部分实现，我们无法实例化抽象类。抽象类的任何子类都必须实现超类中的所有抽象方法，或者声明为抽象类本身。java中的一些预定义类是抽象的。它们依赖于它们的子类来提供完整的实现。例如 JAVA朗：号码是一个抽象类。有关抽象类的更多信息，请参见 java中的抽象类

抽象方法

有时，我们只需要在超类中声明方法。这可以通过指定摘要类型修饰符。这些方法有时被称为 子类责任 因为它们没有在超类中指定的实现。因此，子类必须推翻它们提供方法定义。要声明抽象方法，请使用以下通用形式：

abstract type method-name(parameter-list);

如您所见，没有方法主体。任何扩展抽象类的具体类（即没有抽象关键字的类）都必须重写该类的所有抽象方法。 抽象方法的重要规则：

任何包含一个或多个抽象方法的类也必须声明为抽象的
以下是各种 非法组合 方法的其他修饰符的摘要修饰语：
1. 最终的
2. 抽象本族语
3. 摘要同步
4. 抽象静态
5. 抽象隐私
6. 抽象概念

考虑下面的java程序，说明了如何使用摘要类和方法的关键字。

JAVA

                         // A java program to demonstrate                       
                         // use of abstract keyword.                       
           
                         // abstract with class                       
                         abstract                                     class                                     A                       
                         {                       
                                                 // abstract with method                       
                                                 // it has no body                       
                                                 abstract                                     void                                     m1();                       
                                   
                                                 // concrete methods are still allowed in abstract classes                       
                                                 void                                     m2()                       
                                                 {                       
                                                 System.out.println(                                     "This is a concrete method."                                     );                       
                                                 }                       
                         }                       
           
                         // concrete class B                       
                         class                                     B                                     extends                                     A                       
                         {                       
                                                 // class B must override m1() method                       
                                                 // otherwise, compile-time exception will be thrown                       
                                                 void                                     m1() {                       
                                                 System.out.println(                                     "B's implementation of m1."                                     );                       
                                                 }                       
                                   
                                   
                         }                       
           
                         // Driver class                       
                         public                                     class                                     AbstractDemo                       
                         {                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 B b =                                     new                                     B();                       
                                                 b.m1();                       
                                                 b.m2();                       
                                                 }                       
                         }                       

输出：

B's implementation of m1.This is a concrete method.

注：虽然抽象类不能用来实例化对象，但它们可以用来创建对象引用，因为Java的运行时多态性通过使用超类引用实现。因此，必须能够创建对抽象类的引用，以便使用它来指向子类对象。

抽象与 最终的

在java中，您永远不会看到同时使用这两种语言声明的类或方法最终的和抽象关键词。对于班级，期末考试用于防止遗产而抽象类依赖于它们的子类来完成实现。在使用方法的情况下，使用final来防止最重要的而抽象方法需要在子类中重写。本文由 高拉夫·米格拉尼 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java