컴파일 타임 값 매개 변수를 사용하여 Java 클래스 생성

클래스가 동일한 기본 동작, 메소드 등을 구현하지만 해당 클래스의 여러 버전이 다른 용도로 존재할 수있는 상황을 고려하십시오. 내 특별한 경우에는 벡터 (목록이 아닌 기하학적 벡터)가 있고 그 벡터는 모든 N 차원 유클리드 공간 (1 차원, 2 차원, ...)에 적용될 수 있습니다. 이 클래스 / 타입을 어떻게 정의 할 수 있습니까?

클래스 템플릿이 실제 값을 매개 변수로 가질 수있는 C ++에서는 쉽지만 Java에는 그러한 고급 스러움이 없습니다.

이 문제를 해결하기 위해 취할 수있는 두 가지 접근 방식은 다음과 같습니다.

1. 컴파일 타임에 가능한 각 사례를 구현합니다.

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

   이 솔루션은 시간이 많이 걸리고 코드 작성에 지루합니다. 이 예제에서는 그리 나쁘지는 않지만 실제 코드에서는 최대 4 개의 차원 (x, y, z 및 w)으로 각각 여러 구현이있는 벡터를 처리하고 있습니다. 각 벡터에는 실제로 500 개만 필요하지만 현재 2,000 줄 이상의 코드가 있습니다.

2. 런타임시 매개 변수 지정

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

   불행히도이 솔루션은 코드 성능을 저하시키고 이전 솔루션보다 더 복잡한 코드를 생성하며 컴파일 타임에 안전하지 않습니다 (컴파일 타임에 처리하는 벡터가 실제로 2 차원임을 보장 할 수는 없습니다. 예를 들어).

저는 현재 Xtend에서 실제로 개발 중이므로 Xtend 솔루션을 사용할 수 있다면 수용 할 수 있습니다.

이런 경우 코드 생성을 사용합니다.

실제 코드를 생성하는 Java 응용 프로그램을 작성합니다. 그렇게하면 for 루프를 사용하여 다양한 버전을 쉽게 생성 할 수 있습니다. JavaPoet을 사용 하여 실제 코드를 작성하는 것이 매우 간단합니다. 그런 다음 코드 생성 실행을 빌드 시스템에 통합 할 수 있습니다.

내 응용 프로그램과 매우 유사한 모델이 있으며 솔루션은 솔루션 2와 비슷한 동적 크기의 맵을 유지하는 것이 었습니다.

당신은 단순히 자바 배열 프리미티브와 같은 성능에 대해 걱정할 필요가 없습니다. 10,000 열 x 100 열 (읽기 : 100 차원 벡터)의 상한 크기를 가진 행렬을 생성하며 솔루션보다 훨씬 더 복잡한 벡터 유형으로 성능이 우수합니다. 속도를 높이기 위해 조기 최적화하고 있다고 생각합니다.

코드를 공유 할 기본 클래스를 만들어 성능을 저하시키면서 코드를 절약 할 수 있습니다.

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

물론 Java-8 +를 사용하는 경우 기본 인터페이스를 사용하여 더욱 강화할 수 있습니다.

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
}

궁극적으로 그 이상의 JVM 옵션은 없습니다. 물론 C ++로 작성하고 JNA와 같은 것을 사용하여 그것들을 연결시킬 수 있습니다-이것은 우리가 포트란과 인텔의 MKL을 사용하는 일부 빠른 매트릭스 작업을위한 솔루션입니다. C ++로 행렬을 작성하고 java에서 getter / setter를 호출하면됩니다.

배열 (치수 이름 또는 이와 유사한 매개 변수 목록에서 초기화되거나 크기 또는 빈 구성 요소 배열의 정수-디자인에 대한 정수)로 구성된 생성자를 갖는 각 명명 된 Vector가있는 열거 형과 getMagnitude 메소드 열거 형이 setComponents / getComponent (s)에 대한 인터페이스를 구현하고 getX 등을 제거하여 사용중인 구성 요소를 설정하면됩니다. 사용하기 전에 각 구성 요소를 실제 구성 요소 값으로 초기화하여 입력 배열 크기가 차원 이름 또는 크기와 일치하는지 확인해야합니다.

그런 다음 솔루션을 다른 차원으로 확장하면 열거 형과 람다 만 수정하면됩니다.

당신의 선택 2에 기초하여, 왜 그렇게합니까? raw base를 사용하지 않으려면 abstract base로 만들 수 있습니다.

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

한 가지 아이디어 :

1. getComponent (i) 메소드에 근거한 가변 치수 구현을 제공하는 추상 기본 클래스 Vector입니다.
2. 개별 서브 클래스 Vector1, Vector2, Vector3은 일반적인 경우를 다루며 Vector 메소드를 대체합니다.
3. 일반적인 경우의 DynVector 서브 클래스입니다.
4. 일반적인 경우에 대해 고정 길이 인수 목록을 가진 팩토리 메소드는 Vector1, Vector2 또는 Vector3을 리턴하도록 선언되었습니다.
5. arglist 길이에 따라 Vector1, Vector2, Vector3 또는 DynVector를 인스턴스화하여 Vector를 반환하도록 선언 된 var-args 팩토리 메서드입니다.

이를 통해 일반적인 경우에는 우수한 성능을 제공하고 일반적인 경우를 희생하지 않고도 일부 컴파일 타임 안전성 (아직 개선 될 수 있음)을 제공합니다.

코드 스켈레톤 :

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

}