Tạo các lớp Java với các tham số giá trị thời gian biên dịch

Xem xét một tình huống trong đó một lớp thực hiện cùng một hành vi cơ bản, các phương thức, et cetera, nhưng nhiều phiên bản khác nhau của lớp đó có thể tồn tại cho các mục đích sử dụng khác nhau. Trong trường hợp cụ thể của tôi, tôi có một vectơ (vectơ hình học, không phải danh sách) và vectơ đó có thể áp dụng cho bất kỳ không gian Euclide N chiều nào (1 chiều, 2 chiều, ...). Làm thế nào có thể định nghĩa lớp / loại này?

Điều này sẽ dễ dàng trong C ++ khi các mẫu lớp có thể có các giá trị thực tế làm tham số, nhưng chúng ta không có sự sang trọng đó trong Java.

Hai cách tiếp cận tôi có thể nghĩ ra có thể được thực hiện để giải quyết vấn đề này là:

1. Có một thực hiện của từng trường hợp có thể tại thời gian biên dịch.

   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;
       }
   }
   

   Giải pháp này rõ ràng là rất tốn thời gian và cực kỳ tẻ nhạt để viết mã. Trong ví dụ này có vẻ không tệ lắm, nhưng trong mã thực tế của tôi, tôi đang xử lý các vectơ có nhiều triển khai mỗi cái, với tối đa bốn chiều (x, y, z và w). Tôi hiện có hơn 2.000 dòng mã, mặc dù mỗi vector chỉ thực sự cần 500.

2. Chỉ định tham số khi chạy.

   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];
       }
   }
   

   Thật không may, giải pháp này làm tổn hại đến hiệu suất mã, dẫn đến mã lộn xộn hơn so với giải pháp trước đây và không an toàn ở thời gian biên dịch (không thể đảm bảo tại thời điểm biên dịch rằng vectơ bạn xử lý thực sự là 2 chiều, ví dụ).

Tôi hiện đang thực sự phát triển trong Xtend, vì vậy nếu có bất kỳ giải pháp Xtend nào có sẵn, chúng cũng sẽ được chấp nhận.

Trong trường hợp như thế này, tôi sử dụng tạo mã.

Tôi viết một ứng dụng java tạo mã thực tế. Bằng cách đó, bạn có thể dễ dàng sử dụng vòng lặp for để tạo ra một loạt các phiên bản khác nhau. Tôi sử dụng JavaPoet , điều này làm cho việc xây dựng mã thực tế trở nên khá đơn giản. Sau đó, bạn có thể tích hợp chạy việc tạo mã vào hệ thống xây dựng của mình.

Tôi có một mô hình rất giống với ứng dụng của mình và giải pháp của chúng tôi là chỉ cần giữ một bản đồ có kích thước động, tương tự như giải pháp 2 của bạn.

Đơn giản là bạn sẽ không cần phải lo lắng về hiệu năng với một mảng java nguyên thủy như thế. Chúng tôi tạo ma trận với kích thước giới hạn trên 100 cột (đọc: vectơ 100 chiều) bằng 10.000 hàng và chúng tôi đã có hiệu suất tốt với các loại vectơ phức tạp hơn nhiều so với giải pháp của bạn 2. Bạn có thể thử niêm phong lớp hoặc phương thức đánh dấu là cuối cùng để tăng tốc, nhưng tôi nghĩ bạn đang tối ưu hóa sớm.

Bạn có thể nhận được một số tiết kiệm mã (với chi phí hiệu suất) bằng cách tạo một lớp cơ sở để chia sẻ mã của bạn:

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}; }
}

Tất nhiên, nếu bạn đang sử dụng Java-8 +, bạn có thể sử dụng các giao diện mặc định để làm cho điều này thậm chí còn chặt chẽ hơn:

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
}

Cuối cùng, bạn không còn lựa chọn nào với JVM. Tất nhiên bạn có thể viết chúng bằng C ++ và sử dụng một cái gì đó như JNA để kết nối chúng với nhau - đây là giải pháp của chúng tôi cho một số hoạt động ma trận nhanh, nơi chúng tôi sử dụng MKL của fortran và intel-- nhưng điều này sẽ làm mọi thứ chậm lại nếu bạn chỉ cần viết ma trận của bạn trong C ++ và gọi getters / setters của nó từ java.

Hãy xem xét một enum với mỗi Vector có tên có một hàm tạo bao gồm một mảng (được khởi tạo trong danh sách tham số có tên kích thước hoặc tương tự, hoặc có lẽ chỉ là một số nguyên cho kích thước hoặc mảng thành phần trống - thiết kế của bạn) và lambda cho phương thức getMagnitude. Bạn cũng có thể yêu cầu enum thực hiện giao diện cho setComponents / getComponent (s) và chỉ cần thiết lập thành phần nào trong cách sử dụng của nó, loại bỏ getX, et al. Bạn sẽ cần khởi tạo từng đối tượng với các giá trị thành phần thực tế của nó trước khi sử dụng, có thể kiểm tra xem kích thước mảng đầu vào có khớp với tên hoặc kích thước không.

Sau đó, nếu bạn mở rộng giải pháp sang một chiều khác, bạn chỉ cần sửa đổi enum và lambda.

Dựa trên lựa chọn 2 của bạn, tại sao không chỉ đơn giản là làm điều này? Nếu bạn muốn ngăn chặn việc sử dụng cơ sở thô, bạn có thể làm cho nó trừu tượng:

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);
  }
}

Một ý tưởng:

1. Một lớp cơ sở trừu tượng Vector cung cấp các triển khai kích thước thay đổi dựa trên phương thức getComponent (i).
2. Các lớp con Indiviual Vector1, Vector2, Vector3, bao gồm các trường hợp điển hình, ghi đè các phương thức Vector.
3. Một lớp con DynVector cho trường hợp chung.
4. Các phương thức xuất xưởng với danh sách đối số có độ dài cố định cho các trường hợp điển hình, được khai báo để trả về Vector1, Vector2 hoặc Vector3.
5. Một phương thức nhà máy var-args, được khai báo để trả về Vector, khởi tạo Vector1, Vector2, Vector3 hoặc DynVector, tùy thuộc vào độ dài của đối số.

Điều này mang lại cho bạn hiệu suất tốt trong các trường hợp điển hình và một số an toàn trong thời gian biên dịch (vẫn có thể được cải thiện) mà không phải hy sinh trường hợp chung.

Bộ xương mã:

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;
    }

}