Java Design Struktur

Question

Wenn ich eine Menge Sortierklassen (Einfügen, Zusammenführen, usw.) mit void sort() Methode in allen von ihnen schreiben möchte, dann hatte ich gehofft, eine Schnittstelle oder abstrakte Klasse, die diese Klassen implementieren oder erweitern können von.

Allerdings, wenn ich die sort-Methode als statisch verwenden und statische Methode in abstrakten super-Klasse nicht beibehalten kann.

Was wäre der richtige Weg für eine solche Implementierung?

Answer 1

Wenn ich Ihre Frage richtig verstanden habe, kann eine Lösung zur Verwendung einer static Methode sort(int data [ ]) mit dem Stategym-Muster durchgeführt werden (ich habe Int-Daten verwendet, um das Verständnis zu erleichtern).
Wie Sie sagten, Gruppe alle Ihre Art Strategien wie zum Beispiel InsertionSort, MergeSort, Quicksort etc ... in einer Schnittstelle SortAlgorithm implementieren, um die abstrakte Methode sort(int data []).
schreiben Sie dann eine Klasse Sorter, die einen Verweis auf den abstrakten Typ besitzt SortAlgorithm die final sort(int data [ ], int choice) verwenden, wo choice in meinem Beispiel eine ganze Zahl von dem Client

class Client{ 
    public static void main(String [ ] args){ 
     Scanner sc = new Scanner(System.in); 
     int choice = sc.nextInt(); 
     int data= new int [5] 
     data={3,7,7,1,0}; 
     Sorter.sort(data,choice); 
    } 

Answer 2

Nun, ich glaube, Sie versuchen, machen es kompliziert gegeben ist. Dein Problem ist einfach. Sie müssen nur einige Sortierfunktionen codieren. Sie können nicht versuchen, objektorientiertes Denken überall anzuwenden. Dies ist nur die Implementierung verschiedener wiederverwendbarer Algorithmen. Wenn Sie das wirklich DESIGN brauchen. Sie können auf diese Weise versuchen:

interface Sorter<T> { 

    // This method accepts any type of object and sorts it and return it in sorted order 
    //Used Generics to support all types. You can read T as List or Array if you want to understand it in a simple way 
    public T sort(T t); 
} 



class MergeSort implements Sorter<int[]> { 


    @Override 
    public int[] sort(int[] numbersToSort) { 
    //algorithm goes here 

    } 

} 


class BubbleSort implements Sorter<int[]> { 

    @Override 
    public int[] sort(int[] numbersToSort) { 
     //algorithm goes here 
    } 

} 


class InsertionSort implements Sorter<int[]> { 

    @Override 
    public int[] sort(int[] numbersToSort) { 
     //algorithm goes here 
    } 

} 





enum SortingAlgorithms{ 
INSERTIONSORT, 
BUBBLESORT, 
MERGESORT; 

} 

class SorterFactory { 
    public static Sorter<int[]> getSortingAlgorithm(SortingAlgorithms alg) { 
     switch(alg) { 
     case INSERTIONSORT : 
      return new InsertionSort(); 

     case BUBBLESORT : 
      return new BubbleSort(); 

     case MERGESORT : 
      return new MergeSort(); 

     default: 
      return new BubbleSort(); 
     } 
    } 
} 



public class SortingExecutor { 
    public static void main (String... cmdArgs) { 

     int[] toBeSorted = {6, 7, 1, 0, 3}; 

     //get a bubble sort algorith which can take int[] as input and return the sorted int[] as output 
     Sorter<int[]> bubbleSort = SorterFactory.getSortingAlgorithm(SortingAlgorithms.BUBBLESORT); 
     bubbleSort.sort(toBeSorted); 



    } 
} 

Answer 3

Ein Brückenentwurfsmuster hilft Ihnen hier. Eine Hierarchie enthält verschiedene Aggregate, die die Daten mit der Sorterreferenz in der Basisaggregatklasse enthalten. Eine weitere Hierarchie mit Sorter als Basisklasse bietet verschiedene Arten von Sortieralgorithmen in konkreten Klassen.

Der Vorteil wird sein, dass beide Aspekte unabhängig voneinander wachsen können.

Nur Variation von der Brücke Muster wird sein, dass Aggregate-Sorter Beziehung (Ein wenig ähnlich wie Iterator) bidirektional sein wird