當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文

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。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。