การสร้างคลาส 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;
       }
   }

   เห็นได้ชัดว่าการแก้ปัญหานี้ใช้เวลานานมากและเป็นที่น่าเบื่ออย่างยิ่งสำหรับรหัส ในตัวอย่างนี้ดูเหมือนจะไม่เลวร้ายเกินไป แต่ในรหัสที่แท้จริงของฉันฉันกำลังติดต่อกับเวกเตอร์ที่มีการใช้งานหลายแบบแต่ละอันมีขนาดสูงสุดถึงสี่มิติ (x, y, z และ w) ขณะนี้ฉันมีโค้ดมากกว่า 2,000 บรรทัดแม้ว่าแต่ละเวคเตอร์จะต้องการเพียง 500 เท่านั้น

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

   น่าเสียดายที่วิธีนี้ทำให้ประสิทธิภาพของโค้ดแย่ลงส่งผลให้รหัส messier กว่าโซลูชันเดิมและไม่ปลอดภัยในการคอมไพล์เวลา ตัวอย่างเช่น).

ขณะนี้ฉันกำลังพัฒนาจริง ๆ ใน Xtend ดังนั้นหากมีโซลูชัน Xtend ใด ๆ พร้อมใช้งานพวกเขาก็จะยอมรับได้เช่นกัน

ในกรณีเช่นนี้ฉันใช้การสร้างรหัส

ฉันเขียนแอปพลิเคชัน java ที่สร้างรหัสจริง ด้วยวิธีนี้คุณสามารถใช้ for for loop เพื่อสร้างกลุ่มเวอร์ชันที่แตกต่างกัน ฉันใช้JavaPoetซึ่งทำให้ตรงไปตรงมาเพื่อสร้างรหัสจริง จากนั้นคุณสามารถรวมการรันการสร้างรหัสลงในระบบการสร้างของคุณ

ฉันมีโมเดลที่คล้ายกันมากในแอปพลิเคชันของฉันและโซลูชันของเราคือเพียงเก็บแผนที่ขนาดไดนามิกเช่นเดียวกับโซลูชันของคุณ 2

คุณก็ไม่จำเป็นต้องกังวลเกี่ยวกับประสิทธิภาพด้วย java array primative แบบนั้น เราสร้างเมทริกซ์ที่มีขนาดขอบบน 100 คอลัมน์ (อ่าน: เวกเตอร์ 100 มิติ) 10,000 แถวและเรามีประสิทธิภาพที่ดีด้วยเวกเตอร์ชนิดที่ซับซ้อนกว่าโซลูชันของคุณ 2 คุณอาจลองปิดผนึกคลาสหรือวิธีการทำเครื่องหมายเป็นขั้นสุดท้าย เพื่อเพิ่มความเร็ว แต่ฉันคิดว่าคุณเพิ่มประสิทธิภาพก่อนกำหนด

คุณสามารถประหยัดรหัสได้ (โดยเสียค่าใช้จ่าย) โดยการสร้างคลาสพื้นฐานเพื่อแชร์รหัสของคุณ:

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 เพื่อเชื่อมพวกเขาใน - นี่คือทางออกของเราสำหรับการดำเนินการอย่างรวดเร็วของเมทริกซ์ที่เราใช้ Fortran และ MKL ของ Intel - แต่สิ่งนี้จะช้าลงหาก คุณเขียนเมทริกซ์ของคุณใน C ++ และเรียกใช้ getters / setters จาก java

พิจารณา enum กับ Vector แต่ละชื่อที่มีตัวสร้างที่ประกอบด้วยอาร์เรย์ (เริ่มต้นในรายการพารามิเตอร์ด้วยชื่อมิติหรือคล้ายกันหรืออาจเป็นเพียงจำนวนเต็มสำหรับขนาดหรืออาร์เรย์ส่วนประกอบว่างเปล่า - การออกแบบของคุณ) และแลมบ์ดาสำหรับ วิธีการ getMagnitude คุณสามารถให้ enum ใช้อินเทอร์เฟซสำหรับ setComponents / getComponent (s) และเพียงแค่สร้างส่วนประกอบที่ใช้ในการกำจัด getX และอื่น ๆ คุณจะต้องเริ่มต้นแต่ละวัตถุด้วยค่าจริงขององค์ประกอบก่อนการใช้งานอาจตรวจสอบว่าขนาดอาร์เรย์อินพุตตรงกับชื่อมิติหรือขนาด

จากนั้นหากคุณขยายโซลูชันไปยังอีกมิติหนึ่งคุณเพียงแค่ปรับเปลี่ยน enum และแลมบ์ดา

ตามตัวเลือกที่ 2 ของคุณทำไมไม่ทำเช่นนี้? หากคุณต้องการป้องกันการใช้ฐานดิบคุณสามารถทำให้เป็นนามธรรม:

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)
2. คลาสย่อยแต่ละแบบแยกกัน Vector1, Vector2, Vector3 ครอบคลุมกรณีทั่วไปโดยแทนที่เมธอด Vector
3. คลาสย่อย DynVector สำหรับเคสทั่วไป
4. เมธอดจากโรงงานที่มีรายการอาร์กิวเมนต์ความยาวคงที่สำหรับกรณีทั่วไปซึ่งประกาศให้ส่งคืน Vector1, Vector2 หรือ Vector3
5. วิธีการของโรงงาน var-args ประกาศให้ส่งคืน Vector การสร้างอินสแตนซ์ Vector1, Vector2, Vector3 หรือ DynVector ขึ้นอยู่กับความยาวของรายการ

สิ่งนี้ช่วยให้คุณได้รับประสิทธิภาพที่ดีในกรณีทั่วไปและความปลอดภัยเวลาคอมไพล์ (ยังสามารถปรับปรุงได้) โดยไม่ต้องเสียสละกรณีทั่วไป

โครงกระดูกรหัส:

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

}