Generieren von Java-Klassen mit Wertparametern zur Kompilierungszeit

Stellen Sie sich eine Situation vor, in der eine Klasse dasselbe grundlegende Verhalten, dieselben Methoden usw. implementiert, jedoch mehrere unterschiedliche Versionen dieser Klasse für unterschiedliche Verwendungszwecke vorhanden sein können. In meinem speziellen Fall habe ich einen Vektor (einen geometrischen Vektor, keine Liste) und dieser Vektor könnte auf jeden N-dimensionalen euklidischen Raum (1-dimensional, 2-dimensional, ...) angewendet werden. Wie kann diese Klasse / dieser Typ definiert werden?

Dies wäre in C ++ einfach, wo Klassenvorlagen tatsächliche Werte als Parameter haben können, aber wir haben diesen Luxus in Java nicht.

Die zwei Ansätze, die ich mir vorstellen kann, um dieses Problem zu lösen, sind:

1. Implementierung jedes möglichen Falls zur Kompilierungszeit.

   public interface Vector {
       public double magnitude();
   }
   
   public class Vector1 implements Vector {
       public final double x;
       public Vector1(double x) {
           this.x = x;
       }
       @Override
       public double magnitude() {
           return x;
       }
       public double getX() {
           return x;
       }
   }
   
   public class Vector2 implements Vector {
       public final double x, y;
       public Vector2(double x, double y) {
           this.x = x;
           this.y = y;
       }
       @Override
       public double magnitude() {
           return Math.sqrt(x * x + y * y);
       }
       public double getX() {
           return x;
       }
       public double getY() {
           return y;
       }
   }

   Diese Lösung ist offensichtlich sehr zeitaufwändig und äußerst mühsam für den Code. In diesem Beispiel scheint es nicht schlecht zu sein, aber in meinem eigentlichen Code habe ich es mit Vektoren zu tun, die jeweils mehrere Implementierungen mit bis zu vier Dimensionen (x, y, z und w) haben. Ich habe derzeit über 2.000 Codezeilen, obwohl jeder Vektor wirklich nur 500 benötigt.

2. Parameter zur Laufzeit angeben.

   public class Vector {
       private final double[] components;
       public Vector(double[] components) {
           this.components = components;
       }
       public int dimensions() {
           return components.length;
       }
       public double magnitude() {
           double sum = 0;
           for (double component : components) {
               sum += component * component;
           }
           return Math.sqrt(sum);
       }
       public double getComponent(int index) {
           return components[index];
       }
   }

   Leider beeinträchtigt diese Lösung die Codeleistung, führt zu unübersichtlichem Code als die vorherige Lösung und ist zur Kompilierungszeit nicht so sicher (es kann zur Kompilierungszeit nicht garantiert werden, dass der Vektor, mit dem Sie sich befassen, tatsächlich zweidimensional ist. zum Beispiel).

Ich entwickle derzeit in Xtend. Wenn also Xtend-Lösungen verfügbar sind, sind diese ebenfalls akzeptabel.

In solchen Fällen verwende ich die Codegenerierung.

Ich schreibe eine Java-Anwendung, die den eigentlichen Code generiert. Auf diese Weise können Sie einfach eine for-Schleife verwenden, um eine Reihe verschiedener Versionen zu generieren. Ich benutze JavaPoet , was es ziemlich einfach macht, den eigentlichen Code aufzubauen. Anschließend können Sie die Codegenerierung in Ihr Build-System integrieren.

Ich habe ein sehr ähnliches Modell in meiner Anwendung und unsere Lösung bestand darin, einfach eine Karte mit einer dynamischen Größe zu führen, ähnlich Ihrer Lösung 2.

Mit einem solchen Java-Array-Grundelement müssen Sie sich einfach keine Gedanken über die Leistung machen. Wir generieren Matrizen mit Obergrenzengrößen von 100 Spalten (gelesen: 100 dimensionale Vektoren) mit 10.000 Zeilen, und wir haben eine gute Leistung mit viel komplexeren Vektortypen als Ihre Lösung 2 erzielt. Sie könnten versuchen, die Klasse oder die Markierungsmethoden als endgültig zu versiegeln um es zu beschleunigen, aber ich denke, Sie optimieren vorzeitig.

Sie können Codeeinsparungen erzielen (auf Kosten der Leistung), indem Sie eine Basisklasse erstellen, um Ihren Code gemeinsam zu nutzen:

public interface Vector(){

    abstract class Abstract {           
        protected abstract double[] asArray();

        int dimensions(){ return asArray().length; }

        double magnitude(){ 
            double sum = 0;
            for (double component : asArray()) {
                sum += component * component;
            }
            return Math.sqrt(sum);
        }     

        //any additional behavior here   
    }
}

public class Scalar extends Vector.Abstract {
    private double x;

    public double getX(){
        return x;
    }

    @Override
    public double[] asArray(){
        return new double[]{x};
    }
}

public class Cartesian extends Vector.Abstract {

    public double x, y;

    public double getX(){ return x; }
    public double getY(){ return y; }

    @Override public double[] asArray(){ return new double[]{x, y}; }
}

Wenn Sie Java-8 + verwenden, können Sie natürlich standardmäßige Schnittstellen verwenden, um dies noch enger zu gestalten:

public interface Vector{

    default public double magnitude(){
        double sum = 0;
        for (double component : asArray()) {
            sum += component * component;
        }
        return Math.sqrt(sum);
    }

    default public int dimensions(){
        return asArray().length;
    }

    default double getComponent(int index){
        return asArray()[index];
    }

    double[] asArray();

    // giving up a little bit of static-safety in exchange for 
    // runtime exceptions, we can implement the getX(), getY() 
    // etc methods here, 
    // and simply have them throw if the dimensionality is too low 
    // (you can of course do this on the abstract-class strategy as well)

    //document or use checked-exceptions to indicate that these methods throw IndexOutOfBounds exceptions (or a wrapped version)

    default public getX(){
        return getComponent(0);
    }
    default public getY(){
        return getComponent(1);
    }
    //...


    }

    //as a general rule, defaulted interfaces should assume statelessness, 
    // so you want to avoid putting mutating operations 
    // as defaulted methods on an interface, since they'll only make your life harder
}

Darüber hinaus haben Sie mit der JVM keine Optionen mehr. Sie können sie natürlich in C ++ schreiben und sie mit JNA überbrücken - dies ist unsere Lösung für einige der schnellen Matrixoperationen, bei denen wir die MKL von fortran und Intel verwenden -, aber dies wird die Dinge nur verlangsamen, wenn Sie schreiben einfach Ihre Matrix in C ++ und rufen ihre Getter / Setter von Java aus auf.

Stellen Sie sich eine Aufzählung vor, bei der jeder benannte Vektor einen Konstruktor hat, der aus einem Array (initialisiert in der Parameterliste mit den Dimensionsnamen oder ähnlichem oder vielleicht nur einer Ganzzahl für die Größe oder einem leeren Komponentenarray - Ihrem Design) und einem Lambda für besteht die getMagnitude-Methode. Sie könnten die Aufzählung auch eine Schnittstelle für setComponents / getComponent (s) implementieren lassen und einfach feststellen, welche Komponente welche in ihrer Verwendung war, wodurch getX et al. Sie müssen jedes Objekt vor der Verwendung mit seinen tatsächlichen Komponentenwerten initialisieren und möglicherweise überprüfen, ob die Größe des Eingabearrays mit den Dimensionsnamen oder der Größe übereinstimmt.

Wenn Sie die Lösung dann auf eine andere Dimension erweitern, ändern Sie einfach die Aufzählung und das Lambda.

Warum nicht einfach basierend auf Ihrer Option 2? Wenn Sie die Verwendung der Rohdatenbasis verhindern möchten, können Sie sie abstrakt gestalten:

class Vector2 extends Vector
{
  public Vector2(double x, double y) {
    super(new double[]{x,y});
  }

  public double getX() {
    return getComponent(0);
  }

  public double getY() {
    return getComponent(1);
  }
}

Eine Idee:

1. Ein abstrakter Basisklassenvektor, der Implementierungen mit variablen Dimensionen basierend auf einer getComponent (i) -Methode bereitstellt.
2. Einzelne Unterklassen Vector1, Vector2, Vector3, die die typischen Fälle abdecken und die Vector-Methoden überschreiben.
3. Eine DynVector-Unterklasse für den allgemeinen Fall.
4. Factory-Methoden mit Argumentlisten fester Länge für die typischen Fälle, die als Vector1, Vector2 oder Vector3 zurückgegeben werden.
5. Eine var-args-Factory-Methode, die deklariert ist, um Vector zurückzugeben, und Vector1, Vector2, Vector3 oder DynVector instanziiert, abhängig von der Länge der Arglist.

Dies bietet Ihnen in typischen Fällen eine gute Leistung und eine gewisse Sicherheit während der Kompilierung (kann noch verbessert werden), ohne den allgemeinen Fall zu beeinträchtigen.

Code-Skelett:

public abstract class Vector {
    protected abstract int dimension();
    protected abstract double getComponent(int i);
    protected abstract void setComponent(int i, double value);

    public double magnitude() {
        double sum = 0.0;
        for (int i=0; i<dimension(); i++) {
            sum += getComponent(i) * getComponent(i);
        }
        return Math.sqrt(sum);
    }

    public void add(Vector other) {
        for (int i=0; i<dimension(); i++) {
            setComponent(i, getComponent(i) + other.getComponent(i));
        }
    }

    public static Vector1 create(double x) {
        return new Vector1(x);
    }

    public static Vector create(double... values) {
        switch(values.length) {
        case 1:
            return new Vector1(values[0]);
        default:
            return new DynVector(values);
        }

    }
}

class Vector1 extends Vector {
    private double x;

    public Vector1(double x) {
        super();
        this.x = x;
    }

    @Override
    public double magnitude() {
        return Math.abs(x);
    }

    @Override
    protected int dimension() {
        return 1;
    }

    @Override
    protected double getComponent(int i) {
        return x;
    }

    @Override
    protected void setComponent(int i, double value) {
        x = value;
    }

    @Override
    public void add(Vector other) {
        x += ((Vector1) other).x;
    }

    public void add(Vector1 other) {
        x += other.x;
    }
}

class DynVector extends Vector {
    private double[] values;
    public DynVector(double[] values) {
        this.values = values;
    }

    @Override
    protected int dimension() {
        return values.length;
    }

    @Override
    protected double getComponent(int i) {
        return values[i];
    }

    @Override
    protected void setComponent(int i, double value) {
        values[i] = value;
    }

}