关于flex与java交互的问题

Question

各位前辈好！
本人最近在做一个关于输气管网计算界面的项目，要用到Flex与java通信。我在java里面定义了static变量，然后在flex里面向java传值（传的值有数组类型，也有double类型），然后在java里面实现计算并返回（能不能返回数组？如何做到？在flex里输入到什么组件比较好？）到flex。现在我经过测试发现传值的过程没什么问题，但是返回到flex里老出问题，百思不得其解,请求各位援助。

下面是我的调用的java类：
（注：程序运行没有什么问题的，只是没法被flex调用返回值，我是想调用Final（）或者calculation（）来返回getP（）等）

package danxiang;

import java.sql.ResultSet;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.List;

import domain.Model;
import domain.Result;
import flex.messaging.io.ArrayList;

public class SectionCalculationwj {

static double d[];
static int start[];
public static double deta ;
public static double Z;
static int end[];
static double l[];
static double qq[];
static double Q0[];
static double section[];
public static int point;
public static int ss;
static double P0[] ;
static double T0[];
public static double Th ;
static double K[] ;
public static double  rog ;
public static double cpg ;
public static double Di;

//下面这一部分是在flex里面调用的，从flex里面往这传值

public String initiateqq(double init[])
{
         qq=init;
         return "qq";
 }

public String initiatepoint(int i)
{
        point=i;
        return "point";
    }



public String initiateSection(double init[])
{
         section=init;
         return "section";
}




public String initiateStart(int init[])

{
start=init;
return "start";
}

public String initiateEnd(int init[])

{
end=init;
return "end::"+end[1];
}

    public String initiated(double init[])
{
         d=init;
         return "D:::"+d[1];
 }  


    public String initiatel(double init[])
{
         l=init;

         return "L:::"+l[1];
}

    public String initiateT0(double init[])
{
         T0=init;

        return "T0";
}


    public String initiateQ0(double init[])
    {
             Q0=init;
            return "Q0";
    }


    public  String initiateP(double init[])
    {
        P0=init;
     return "P0";
    }



    public String initiateK(double init[])
{
         K=init;

        return "K";
}







    public double initiatedeta(double DETA)
    {
             deta=DETA;
            return deta;
    }
    public double initiatess(int S)
    {
             ss=S;
            return ss;
    }
    public double initiaterog(double ROG)
    {
             rog=ROG;
            return rog;
    }
    public double initiatecpg(double C)
    {
             cpg=C;
            return cpg;
    }
    public double initiateDi(double di)
    {
             Di=di;
            return Di;
    }
    public double initiateTh(double th)
    {
             Th=th;
            return Th;
    }
    public double initiateZ(double zz)
    {
             Z=zz;
            return Z;
    }

//
//
//下面是我希望调用的，并返回到flex里面。。

// public String Final() {
// SectionCalculationwj aa = new SectionCalculationwj();
// aa.calculation();
// return "Hello,成功了！";
//

// }

public double[] calculation() {

    int step = 0;
    Result result = new Result();
    //第一步，取初值
    Model model = getInitValue();
    //节点数
    int n = model.getPoint();
    //管道数
    int m = model.getSection().length;
    //计算出A，Azz
    result.setA(A(model));
    result.setAzz(Azz(result.getA()));
    result.setP(model.getP0());
    result.setAverageP(averageP(model, result));
    double condition;
    result.setQx(model.getQ0());
    result.setT(model.getT0());
    result.setBw(bw(result));




    do {
        result.setSj(Sj(model, result));
        double[] tempQ = {};
        //算AGA之前先求出G
        result.setG(G(result.getSj(), result.getQx()));
        result.setAGA(AGA(result));
        fenkuai kf = new fenkuai();
        result.setP(kf.fk(result.getAGA(), model.getSs(), result.getP(), model.getQq()));
        result.setAverageP(averageP(model, result));
        result.setDetap(detap(result));
        tempQ = Qnew(result);
        condition = condition(tempQ, result.getQx());
        for (int k = 0; k < tempQ.length; k++) {
            tempQ[k] = (result.getQx()[k] + tempQ[k]) / 2;
        }
        result.setQx(tempQ);

// 温降 水

        result.setAa(aa(model, result));
        result.setT(resetT(model, result));

// 水的析出
result.setBw(bw(result));
result.setDetabw(detabw(model,result));
step += 1;

    } while (condition > 0.001);

    System.out.println(step);
    for (int i = 0; i < 12; i++) {
        System.out.println("" + result.getP()[i]);
    }
    for (int i = 0; i < 12; i++) {
        System.out.println("" + result.getT()[i]);
    }
    for (int i = 0; i < 11; i++) {
        System.out.println("" + result.getDetabw()[i]);
    }


  return  result.getP();

}

public double[][] A(Model model) {
int[] start = model.getStart();
int[] end = model.getEnd();
double[] section = model.getSection();
int n = model.getPoint();
int m = section.length;
double[][] A = new double[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i + 1 == start[j]) {
A[i][j] = -1;
}
if (i + 1 == end[j]) {
A[i][j] = 1;
} else if (i + 1 != start[j] && i + 1 != end[j]) {
A[i][j] = 0;
}
}
}
return A;
}
//将A矩阵转置

public double[][] Azz(double[][] A) {
    int n = A.length;
    int m = A[0].length;
    double[][] Azz = new double[m][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            Azz[j][i] = A[i][j];
        }
    }
    return Azz;
}
// 计算Sj

public double[] Sj(Model model, Result result) {
    double[] section = model.getSection();
    double[] D = model.getD();
    double[] L = model.getL();
    double[] T = result.getT();
    double deta = model.getDeta();
    double Z = model.getZ();
    double[] averageP = result.getAverageP();
    //第一步，计算lam的值
    int m = section.length;
    double[] lam = new double[m];
    double[] Sj = new double[m];
    for (int i = 0; i < m; i++) {
        lam[i] = 0.009407 / Math.pow(D[i], (1.0 / 3));
    }
    //第二步，计算Sj
    for (int i = 0; i < m; i++) {
        Sj[i] = -675.3515 * lam[i] * deta * Z * T[i] * L[i] / Math.pow(D[i], 5) / (2 * averageP[i]);
    }
    return Sj;
}
// 计算G

public double[][] G(double[] Sj, double[] Q) {
    int m = Sj.length;
    double[][] G = new double[m][m];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            if (i == j) {
                G[i][j] = 1 / Sj[i] / Math.abs(Q[i]);
            } else {
                G[i][j] = 0;
            }
        }
    }
    return G;
}
//计算AGA

public double[][] AGA(Result result) {
    double[][] G = result.getG();
    double[][] A = result.getA();
    double[][] Azz = result.getAzz();
    int n = A.length;
    int m = A[0].length;
    double AG[][] = new double[n][m];
    double AGA[][] = new double[n][n];
    for (int i = 0; i < A.length; i++) {
        for (int j = 0; j < G[0].length; j++) {
            for (int k = 0; k < G.length; k++) {
                AG[i][j] += A[i][k] * G[k][j];
            }
        }
    }
    for (int i = 0; i < AG.length; i++) {
        for (int j = 0; j < Azz[0].length; j++) {
            for (int k = 0; k < Azz.length; k++) {
                AGA[i][j] += AG[i][k] * Azz[k][j];
            }
        }
    }
    return AGA;
}

public double[] detap(Result result) {
    double[][] Azz = result.getAzz();
    double[] p = result.getP();
    int m = Azz.length;
    int n = Azz[0].length;
    double[] detap = new double[m];
    //计算压力降
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            detap[i] += Azz[i][j] * p[j];
        }
    }
    return detap;
}

public double[] averageP(Model model, Result result) {
    double[] P = result.getP();
    int[] start = model.getStart();
    int[] end = model.getEnd();
    int m = start.length;
    double[] averageP = new double[m];
    for (int j = 0; j < m; j++) {
        averageP[j] = 0.5 * (P[start[j] - 1] + P[end[j] - 1]);
    }
    return averageP;
}

public double[] Qnew(Result result) {
    //计算新流量
    double[][] G = result.getG();
    double[] detap = result.getDetap();
    int m = G.length;
    double[] Qnew = new double[m];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            Qnew[i] += G[i][j] * detap[j];
        }
    }
    return Qnew;
}

public double condition(double[] tempQ, double[] Q) {
    int m = tempQ.length;
    double condition = 0.0;
    for (int i = 0; i < m; i++) {
        condition += Math.pow((tempQ[i] - Q[i]), 2);
    }
    condition = Math.pow(condition, 0.5);
    return condition;
}
//单相温降计算

public double[] aa(Model model, Result result) {
    double[] Q = result.getQx();
    double[] D = model.getD();
    double[] K = model.getK();
    double rog = model.getRog();
    double cpg = model.getCpg();
    double[] bw=result.getBw();
    int m = Q.length;
    double[] aa = new double[m];
    for (int i = 0; i < m; i++) {
        aa[i] = K[i] * Math.PI * D[i] / ((rog+bw[i]) * Q[i] * cpg )/1000000;
    }
    return aa;
}

public double[] resetT(Model model, Result result) {
    double Th = model.getTh();
    int[] start = model.getStart();
    int[] end = model.getEnd();
    double[] T = result.getT();
    double[] aa = result.getAa();
    double[] l = model.getL();
    double Di = model.getDi();
    double[] detap = result.getDetap();
    int m = aa.length;
    for (int i = 0; i < m; i++) {
        T[end[i] - 1] = Th + ((T[start[i] - 1]) - Th) * Math.exp(-aa[i] * l[i]) + Di * detap[i] / 1000000 * (1 - Math.exp(-aa[i] * l[i])) / aa[i] / l[i];
    }
    return T;
}
 //饱和水的计算kg/m3直接加在气体密度上
      public double[] bw(Result result) {
    double[] T = result.getT();       
    double[] P=result.getP();
    int m = P.length;
      double[] pb=new double[m];//饱和蒸汽压
    double[] bw = new double[m];
     // y = 0.06233 x3 + 0.60057 x2 + 46.27664 x + 643.34653     xOC，ypa      
    for (int j = 0; j < m; j++) {
        pb[j] = 0.06233*Math.pow(T[j]-273.15,3)+0.60057*Math.pow(T[j]-273.15,2)+46.27664*(T[j]-273.15)+643.34653;
        bw[j]=803*pb[j]/(P[j]-pb[j])*0.001;
    }
    return bw;
}   
 //起终点水量变化计算    >0进水,<0析出水  单位kg
     public double[] detabw(Model model,Result result) {
    double[] bw = result.getBw();
    int[] start=model.getStart();
    int[] end=model.getEnd();
    double[]d=model.getD();
    double[]L=model.getL();
    int m = start.length;
    double[] detabw = new double[m];
    for (int j = 0; j < m; j++) {
        detabw[j] = (bw[end[j]-1] - bw[start[j]-1])*(Math.PI*Math.pow(d[j], 2)/4)*L[j];
    }
    return detabw;
}

}

Answer 1

把calculation方法中的代码全放到下面的代码处，try{代码 } catch(Exception e){e.printStackTrace();}