当前位置: 首页>>代码示例 >>用法及示例精选 >>正文

Java Abstract用法及代码示例


在Java中，抽象类是用abstract关键字声明的。它可能同时具有抽象和非抽象方法(带有主体的方法)。抽象是适用于 Java 中的类和方法的 Java 修饰符，但是不适用于变量。在这篇文章中，我们将学习Java中抽象类的使用。

Java中的抽象类是什么？

Java抽象类是一个不能由自身启动的类，它需要被另一个类子类化才能使用它的属性。抽象类是在其类定义中使用 “abstract” 关键字声明的。

抽象类的图示

abstract class Shape 
{
    int color;
    // An abstract function
    abstract void draw();
}

在Java中，有以下一些重要观察关于抽象类如下：

  1. 无法创建抽象类的实例。
  2. 允许构造函数。
  3. 我们可以有一个没有任何抽象方法的抽象类。
  4. 可以有一个最终方法在抽象类中，但类(抽象类)中的任何抽象方法都不能声明为最终方法，或者简单地说，最终方法本身不能是抽象的，因为它会产生错误：“修饰符的非法组合：抽象和最终”
  5. 我们可以在抽象类中定义静态方法
  6. 我们可以使用抽象关键字用于声明顶级类(外部类)以及内部类作为抽象的
  7. 如果一个类至少包含一种抽象方法那么强制应该将一个类声明为抽象类
  8. 如果儿童班无法为所有抽象方法提供实现家长班那么我们应该声明作为抽象的子类以便下一级子类应该为剩余的抽象方法提供实现

Java抽象类的例子

1. 具有抽象方法的抽象类示例

下面是上述主题的实现：

Java 


// Abstract class
abstract class Sunstar {
    abstract void printInfo();
}
// Abstraction performed using extends
class Employee extends Sunstar {
    void printInfo()
    {
        String name = "avinash";
        int age = 21;
        float salary = 222.2F;
        System.out.println(name);
        System.out.println(age);
        System.out.println(salary);
    }
}
// Base class
class Base {
    public static void main(String args[])
    {
        Sunstar s = new Employee();
        s.printInfo();
    }
}
输出 
avinash
21
222.2

2. 具有构造函数、数据成员和方法的抽象类

抽象类可以有的元素

  • 数据成员
  • 抽象方法
  • 方法体(非抽象方法)
  • constructor
  • main() 方法。

下面是上述主题的实现：

Java 


// Java Program to implement Abstract Class
// having constructor, data member, and methods
import java.io.*;
abstract class Subject {
    Subject() { 
      System.out.println("Learning Subject"); 
    }
   
      abstract void syllabus();
   
      void Learn(){
          System.out.println("Preparing Right Now!");
    }
}
class IT extends Subject {
  void syllabus(){
    System.out.println("C , Java , C++");
  }
}
class GFG {
    public static void main(String[] args) {
        Subject x=new IT();
       
          x.syllabus();
          x.Learn();
    }
}
输出 
Learning Subject
C , Java , C++
Preparing Right Now!

抽象类的属性

让我们详细说明这些观察结果，并在干净的 Java 程序的帮助下证明它们的合理性，如下所示。

观察1

在 Java 中，就像在 C++ 中一样，无法创建抽象类的实例，但我们可以引用抽象类类型。通过干净的Java程序如下所示。

示例

Java 


// Java Program to Illustrate 
// that an instance of Abstract
// Class can not be created
// Class 1
// Abstract class
abstract class Base {
    abstract void fun();
}
// Class 2
class Derived extends Base {
    void fun()
    {
        System.out.println("Derived fun() called");
    }
}
// Class 3
// Main class
class Main {
    // Main driver method
    public static void main(String args[])
    {
        // Uncommenting the following line will cause
        // compiler error as the line tries to create an
        // instance of abstract class. Base b = new Base();
        // We can have references of Base type.
        Base b = new Derived();
        b.fun();
    }
}
输出 
Derived fun() called

观察2

与 C++ 一样，抽象类可以包含构造函数在 Java 。当创建继承类的实例时，将调用抽象类的构造函数。如下程序所示：

例子：

Java 


// Java Program to Illustrate Abstract Class 
// Can contain Constructors
// Class 1
// Abstract class
abstract class Base {
    // Constructor of class 1
    Base()
    {
        // Print statement
        System.out.println("Base Constructor Called");
    }
    // Abstract method inside class1
    abstract void fun();
}
// Class 2
class Derived extends Base {
    // Constructor of class2
    Derived()
    {
        System.out.println("Derived Constructor Called");
    }
    // Method of class2
    void fun()
    {
        System.out.println("Derived fun() called");
    }
}
// Class 3
// Main class
class GFG {
    // Main driver method
    public static void main(String args[])
    {
        // Creating object of class 2
        // inside main() method
        Derived d = new Derived();
        d.fun();
    }
}
输出 
Base Constructor Called
Derived Constructor Called
Derived fun() called

观察3

在Java中，我们可以有没有任何抽象方法的抽象类。这使我们能够创建无法实例化而只能继承的类。在干净的java程序的帮助下如下所示。

例子：

Java 


// Java Program to illustrate Abstract class
// Without any abstract method
// Class 1
// An abstract class without any abstract method
abstract class Base {
    // Demo method. This is not an abstract method.
    void fun()
    {
        // Print message if class 1 function is called
        System.out.println(
            "Function of Base class is called");
    }
}
// Class 2
class Derived extends Base {
    // This class only inherits the Base class methods and
    // properties
}
// Class 3
class Main {
    // Main driver method
    public static void main(String args[])
    {
        // Creating object of class 2
        Derived d = new Derived();
        // Calling function defined in class 1 inside main()
        // with object of class 2 inside main() method
        d.fun();
    }
}
输出 
Function of Base class is called

观察4

抽象类还可以有最后方法(不能被覆盖的方法)

例子：

Java 


// Java Program to Illustrate Abstract classes
// Can also have Final Methods
// Class 1
// Abstract class
abstract class Base {
    final void fun()
    {
        System.out.println("Base fun() called");
    }
}
// Class 2
class Derived extends Base {
   
}
// Class 3
// Main class
class GFG {
    // Main driver method
    public static void main(String args[])
    {
        {
            // Creating object of abstract class
            Base b = new Derived();
            // Calling method on object created above
            // inside main method
            b.fun();
        }
    }
}
输出 
Base fun() called

观察5

对于任何抽象 java 类，我们都不允许创建对象，即，对于抽象类实例化是不可能的。

Java 


// Java Program to Illustrate Abstract Class
// Main class
// An abstract class
abstract class GFG {
    // Main driver method
    public static void main(String args[])
    {
        // Trying to create an object
        GFG gfg = new GFG();
    }
}

输出：

abstract class

观察6

类似的接口我们可以在抽象类中定义静态方法那可以在没有对象的情况下独立调用。

Java 


// Java Program to Illustrate 
// Static Methods in Abstract
// Class Can be called Independently
// Class 1
// Abstract class
abstract class Helper {
    // Abstract method
    static void demofun()
    {
        // Print statement
        System.out.println("Geeks for Geeks");
    }
}
// Class 2
// Main class extending Helper class
public class GFG extends Helper {
    // Main driver method
    public static void main(String[] args)
    {
        // Calling method inside main()
        // as defined in above class
        Helper.demofun();
    }
}
输出 
Geeks for Geeks

观察7

我们可以使用抽象关键字用于将顶级类(外部类)以及内部类声明为抽象类

Java 


import java.io.*;
abstract class B {
    // declaring inner class as abstract with abstract
    // method
    abstract class C {
        abstract void myAbstractMethod();
    }
}
class D extends B {
    class E extends C {
        // implementing the abstract method
        void myAbstractMethod()
        {
            System.out.println(
                "Inside abstract method implementation");
        }
    }
}
public class Main {
    public static void main(String args[])
    {
        // Instantiating the outer class
        D outer = new D();
        // Instantiating the inner class
        D.E inner = outer.new E();
        inner.myAbstractMethod();
    }
}
输出 
Inside abstract method implementation

观察8

如果一个类至少包含一个抽象方法然后我们必须将类声明为抽象类否则我们会得到一个编译时错误，如果一个类至少包含一个抽象方法，那么该类的实现不完整，因此不建议创建对象，因此为了限制此类部分类的对象创建我们用抽象关键字。

Java 


/*package whatever //do not write package name here */
import java.io.*;
// here if we remove the abstract 
// keyword then we will get compile
// time error due to abstract method
abstract class Demo {
    abstract void m1();
}
class Child extends Demo {
    public void m1() 
    { 
      System.out.print("Hello"); 
    }
}
class GFG {
    public static void main(String[] args)
    {
        Child c = new Child();
        c.m1();
    }
}
输出 
Hello

观察9

如果孩子类无法为父类的所有抽象方法提供实现，那么我们应该将子类声明为抽象类，以便下一级子类应该为剩余的抽象方法提供实现。

Java 


// Java Program to demonstrate
// Observation 
import java.io.*;
abstract class Demo {
    abstract void m1();
    abstract void m2();
    abstract void m3();
}
abstract class FirstChild extends Demo {
    public void m1() {
      System.out.println("Inside m1"); 
    }
}
class SecondChild extends FirstChild {
    public void m2() {
      System.out.println("Inside m2"); 
    }
    public void m3() {
      System.out.println("Inside m3");
    }
}
class GFG {
    public static void main(String[] args)
    {
        // if we remove the abstract keyword from FirstChild
        // Class and uncommented below obj creation for
        // FirstChild then it will throw
        // compile time error as did't override all the
        // abstract methods
        // FirstChild f=new FirstChild();
        // f.m1();
        SecondChild s = new SecondChild();
        s.m1();
        s.m2();
        s.m3();
    }
}
输出 
Inside m1
Inside m2
Inside m3

在 C++ 中，如果一个类至少有一个纯虚函数，那么类就变得抽象了。与C++不同，在Java中，使用单独的关键字abstract来使类抽象。

结论

本文中需要记住的要点如下：

  • 抽象类是一个不能由自身启动的类，它需要被另一个类子类化才能使用它的属性。
  • 可以使用“abstract”关键字创建抽象类。
  • 我们可以有一个没有任何抽象方法的抽象类。

抽象类常见问题解答

1.Java中什么是抽象类？

An abstract class in Java is a class that can not be initiated on its own but can be used as a subclass by another class.

2. 抽象类的目的是什么？

The main purpose of the abstract class is to create a base class from which many other classes can be derived.

3. 抽象类的主要优点是什么？

An abstract class provides the provides of data hiding in Java.

4. 为什么抽象类比接口快？

An abstract class is faster than an interface because the interface involves a search before calling any overridden method in Java whereas abstract class can be directly used. 

另外，阅读



相关用法


注：本文由纯净天空筛选整理自佚名大神的英文原创作品 Abstract Class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。