如何以及何時使用抽象類

Question

這是我在java中的測試程序。我想知道這裏有多少抽象類更重要，以及爲什麼我們使用抽象類來做到這一點。

這是強制還是最好的方法;如果是的話如何？

class Shape1 { 

int i=1; 
void draw(){ 
System.out.println("this is shape:"+i); 
} 
} 

class Shape2 { 

int i=4; 
void draw(){ 
System.out.println("this is shape2:"+i); 
} 
} 


class Shape { 

public static void main(String args[]) 
{ 
Shape1 s1 = new Shape1(); 
s1.draw(); 

Shape2 s2 = new Shape2(); 
s2.draw(); 
} 
} 

Answer 1

抽象類，顧名思義就是抽象類。

抽象類不談論實現部分。事實上，我們擴展抽象類來爲其抽象方法提供實現。它也可以有非抽象的方法。

入住這裏：Use of Abstract Class in Java

編輯：

示例代碼：

abstract class Shapes { 

int i=1; 
abstract void draw(); 

// Remember : Non-abstract methods are also allowed 
void fill() { 
    System.out.println("Non abstract method - fill"); 
} 
} 

class Shape1 extends Shapes { 

int i=1; 
void draw(){ 
System.out.println("This is Shape 1:"+i); 
} 
} 

class Shape2 extends Shapes { 
    int i=2; 
    void draw() { 
     System.out.println("This is Shape 2:"+i); 
    } 
} 

class Shape { 

public static void main(String args[]) 
     { 
     Shape1 s1 = new Shape1(); 
     s1.draw();      // Prints This is Shape 1:1 

     Shape2 s2 = new Shape2(); 
     s2.draw();      // Prints This is Shape 2:2 
     } 
    } 

Answer 2

一個抽象類有一個 「是」 的類型與子類的關係。例如，你可以有一個抽象類Shape，它具有任何形狀的東西（如繪圖函數），然後是類SquareShape。每個方形都是一個形狀，但並不是所有的形狀都是方形。

在你的例子中，你有2個形狀類型和一個有2個這樣的實例的類。這不是你應該用abstract來定義的關係。

雖然你可能想用你的名字做一些事情，因爲這是一個很小的例子，很難看到這些文件的真正含義以及它們應該如何工作。

Answer 3

在這裏您將使用抽象類或接口來創建提供void draw()方法的公共基類/接口，例如，

abstract class Shape() { 
    void draw(); 
} 

class Circle extends Shape { 
    void draw() { ... } 
} 

... 

Shape s = new Circle(); 
s.draw(); 

我一般使用的接口。但是，如果您使用以下抽象類：

1. 您需要/想要提供通用功能或類成員（例如您的案例中的int i成員）。
2. 你的抽象方法比公共訪問（這是允許的接口的唯一通道型），如其他任何在我的示例中，void draw()將具有包可見性。

Answer 4

抽象類是一個類，它至少有一個未實現的方法或關鍵字抽象。例如，一個抽象方法可能看起來像這樣：

public abstract String myMethod(String input);

（注意，該方法與分號結束時）。

而且一類可能是這樣的：

public abstract class MyClass { 

    public abstract String myMethod(String input); 

    public String anotherMethod(String input) { 
     return intput + " additional text"; 
    } 
} 

一個抽象類不能被實例化。抽象類需要一個子類來實現缺失的行爲，以便它可以被實例化。

抽象類的主要目標是提供共同行爲的共享實現 - 促進代碼的重用。

在Java中，通過使用類的組合而不是廣義定義的抽象類的繼承，可以實現相同的效果。這允許更多模塊化，功能特定的類來促進代碼重用，從而增加可維護性。

我的建議是僅在嚴格需要時才使用抽象類，特別是避免將它用作充滿各種功能的竅門。

在斯卡拉，人們會使用特質，這是一種優雅的方式來解決這個問題。然而，它需要很多的關注才能正確實現。

Answer 5

在java中使用抽象類的示例示例。

package use_of_abstract; 

abstract class Shapes 
{ 
    int i=1; 

    abstract void draw(); 
    abstract void color(String mycolor); 

    //not an abstract method 
    void fill() 
    { 
     System.out.println("Non-Abstract Method -> Fill"); 
    } 

    //not an abstract method 
    String anotherMethod(String input) 
    { 
     return input + " additional text"; 
    } 

} 

---

package use_of_abstract; 

public class Shape_One extends Shapes 
{ 
    int i=1; 

    @Override 
    void draw() 
    { 
     System.out.println("This is Shape One:"+i); 
    } 

    @Override 
    void color(String mycolor) 
    { 
     System.out.println("This is Shape One:"+mycolor); 

    } 

    @Override 
    String anotherMethod(String anotherMethod) 
    { 
     System.out.println("This is Shape One:"+anotherMethod); 
     return anotherMethod; 

    } 

} 

---

package use_of_abstract; 

public class Shape_Two extends Shapes 
{ 
    int i=2; 

    @Override 
    void draw() 
    { 
     System.out.println("This is Shape Two :"+i); 
    } 

    @Override 
    void color(String mycolor) 
    { 
     System.out.println("This is Shape Two Color:"+mycolor); 
    } 

    @Override 
    String anotherMethod(String anotherMethod) 
    { 
     System.out.println("This is Shape Two:"+anotherMethod); 
     return anotherMethod; 

    } 

} 

---

package use_of_abstract; 

import java.awt.Color; 

public class Shape_Main 
{ 

    public static void main(String args[]) 
    { 
     Shape_One s1; 
     Shape_Two s2; 

     s1=new Shape_One(); 
     s2= new Shape_Two(); 

     s1.draw(); 
     s2.draw(); 

     s1.fill(); 
     s2.fill(); 

     s1.color("Blue"); 
     s2.color("Green"); 


     s1.anotherMethod("HELLO..............Its Another Method 1"); 
     s2.anotherMethod("HELLO..............Its Another Method 2"); 


    } 
} 

Answer 6

抽象類是包含一個或多個抽象方法的類。抽象方法是一種聲明的方法，但不包含任何實現。抽象類可能不會被實例化，並且需要子類爲抽象方法提供實現。我們來看一個抽象類和抽象方法的例子。

假設我們通過創建一個以名爲Animal的基類開始的類層次結構來模擬動物的行爲。動物能夠做不同的事情，如飛行，挖掘和行走，但也有一些常見的操作，如進食和睡覺。一些常見的操作是由所有的動物執行的，但也以不同的方式進行。當以不同的方式執行操作時，它是抽象方法（迫使子類提供自定義實現）的理想選擇。讓我們來看看一個非常原始的動物基類，它定義了一種用於發出聲音的抽象方法（例如狗吠，牛mo或豬叮叮）。

public abstract class Animal 
{ 
    public void eat(Food food) 
    { 
     // do something with food.... 
    } 

    public void sleep(int hours) 
    { 
     try 
    { 
     // 1000 milliseconds * 60 seconds * 60 minutes * hours 
     Thread.sleep (1000 * 60 * 60 * hours); 
    } 
    catch (InterruptedException ie) { /* ignore */ } 
    } 

    public abstract void makeNoise(); 
} 

請注意，abstract關鍵字用於表示抽象方法和抽象類。現在，任何想要實例化的動物（如狗或牛）都必須實施makeNoise方法 - 否則無法創建該類的實例。讓我們看看擴展Animal類的Dog和Cow子類。

public Dog extends Animal 
{ 
    public void makeNoise() { System.out.println ("Bark! Bark!"); } 
} 

public Cow extends Animal 
{ 
    public void makeNoise() { System.out.println ("Moo! Moo!"); } 
} 

現在你可能會奇怪，爲什麼不聲明一個抽象類作爲接口，並有狗和牛實現的接口。當然你可以 - 但你也需要實施吃和睡的方法。通過使用抽象類，您可以繼承其他（非抽象）方法的實現。你不能用接口來實現 - 接口不能提供任何方法實現。