想知道这几个类的作用，帮忙写下注释

Question

// PCMatrix.java
public class PCMatrix {
  private int size;
  private double [][]V;
  
  public PCMatrix(int sz ){
    int k;
    if(sz < 3) k =3;  //to hold lamda, CI & CR
    else k = sz;
    V = new double[k+1][k+2];
    for (int i = 0; i < sz; i++) {
         for (int j = 0; j < sz; j++) {
            V[i][j] = 1.0;
         }
   }  
    size=sz;
  }
  
  public void set(int i,int j, double value) {
    V[i][j] = value;
    V[j][i] = 1.0/value;
  }   public void calculate()
  { 
    cal_total_row();
    normalize();
    cal_PV();
    cal_CR();
   }
  public double getCR()  {
     return V[2][size+1]; 
  }
  public double getPV(int n)  {
     return V[n][size]; 
  }
  public int getSize() {
    return this.size;
  }
 
     private void cal_total_row(){
  double ss;
      for (int j = 0; j < size; j++)
      {
       ss = 0;
          for (int i = 0; i < size; i++) 
                 ss += V[i][j];
          V[size][j] = ss;
      }    
  }
      // 往上除
  private void normalize()
  {   for (int j = 0; j < size; j++)
          for (int i = 0; i < size; i++)
          V[i][j] = V[i][j]/V[size][j]; 
     }
  
  private void cal_PV(){
  double ss;
      for (int i = 0; i < size; i++)
      {   ss = 0;
          for (int j = 0; j < size; j++)
                 ss += V[i][j];
          V[i][size] = ss/size;
       }    
   }
  
  private void cal_CR(){
       V[0][size+1]= calLambda();
       V[1][size+1] = calCI();
       V[2][size+1] = calCR();
    }
  
  private double calLambda(){
  double lambda = 0.0;
      for (int k = 0; k < size; k++)
         lambda += V[size][k] * V[k][size];
      return lambda;
  }
  
  private double calCI()  {
    if (getSize()<=1) return 0.0;
    return (V[0][size+1] - size)/ (size-1.0); 
  }
  
  private double calCR(){
    if (getSize()<=2) return 0.0;
    return calCI()/getRI();
  }
  public double getLamda()  {
     return V[0][size+1]; 
  }
  public double getCI()  {
     return V[1][size+1]; 
  }

  private double getRI(){
    switch (size)
    {
      case 0 : return 0.00;
      case 1 : return 0.00;
      case 2 : return 0.00;
      case 3 : return 0.58;
      case 4 : return 0.90;
      case 5 : return 1.12;
      case 6 : return 1.24;
      case 7 : return 1.32;
      case 8 : return 1.41;
      case 9 : return 1.45;
      case 10: return 1.49;
      default : return 1.5; 
    }
  }
};
// AHPNode.java
import java.util.ArrayList;
public class AHPNode
{
   private ArrayList<AHPNode> sons;
   private PCMatrix pm;
   public String name;
   public double weight;
   static public double temp=0.0;
     
   public AHPNode(String na)
   {   name = na;
   pm = null;
   sons = new ArrayList<AHPNode>();
   }
   
   public void setPCMatrix(PCMatrix p_matrix, String [] caNames)
   {
   pm = p_matrix;
   int n = pm.getSize();
   for(int k = 0; k < n; k++ )
  sons.add(new AHPNode(caNames[k]));    
}
   
   public int size()
   {
   return pm.getSize();
   }
   public AHPNode get_ca(int k)
   {
   return sons.get(k);
   }
   public void printPV(){
  System.out.printf("%s\n", name);
  System.out.printf("   %7.3f\n", pm.getPV(0));
  System.out.printf("   %7.3f\n", pm.getPV(1));
  System.out.printf("   %7.3f\n", pm.getPV(2));
   }
   public void cal_PV_CR_recursive()
   {   if(pm == null) return;
   pm.calculate();
   if(pm.getCR() > 0.1) /* is Not Consistency */
    System.out.printf("%s's CR is NOT Consistent! %7.4f!\n", name, pm.getCR());
   int sz = pm.getSize();
   for(int k=0; k < sz; k++ )
   this.get_ca(k).cal_PV_CR_recursive();
   }
   public void cal_weight_recursive()
   {   AHPNode nd;
   if(pm == null) return;
   int sz = pm.getSize();
   for(int k=0; k < sz; k++ )
   {
  nd = this.get_ca(k);
  nd.weight = weight * pm.getPV(k);
  nd.cal_weight_recursive();
   }
   }
   public void goal_initial(){
   weight = 1.0;
   }
   public void print_weight(){
  System.out.printf("%s --> Value: %6.4f\n", name, weight);
   }
   
   public void alternative_wieght_recursice(String na){
       int sz;
   if(pm == null)
   { // System.out.printf("%s\n", name);
      if(name == na)
         temp += weight;
      sz =0;
   }
   else
   sz = pm.getSize();
   
   for(int k=0; k < sz; k++ )
   {
  this.get_ca(k).alternative_wieght_recursice(na);
   }
   }
}
// JMain.java
public class JMain {
private AHPNode goal, ca0, ca1, ca00, ca01, ca10, ca11, ca12;

void Input_PCMatrix(){
goal = new AHPNode("Evaluate Build Quality");
String [] goalNames = { "Performance", "Functionality" };
goal.goal_initial();
PCMatrix mm = new PCMatrix(2);
mm.set(0, 1, 0.25);
goal.setPCMatrix(mm, goalNames);
//=======================================
ca0 = goal.get_ca(0);
        String [] ca0Names = { "StartUp", "File Save" };
        mm = new PCMatrix(2);
mm.set(0, 1, 5);
ca0.setPCMatrix(mm, ca0Names);
//=======================================
ca1 = goal.get_ca(1);
String [] ca1Names = { "User Interface", "Database", "Network"};
    mm = new PCMatrix(3);
mm.set(0, 1, 3);
mm.set(0, 2, 7);
mm.set(1, 2, 2);
ca1.setPCMatrix(mm, ca1Names);
//=======================================
String [] choiceNames = { "Build A", "Build B", "Build C"};
ca00 = ca0.get_ca(0);
mm = new PCMatrix(3);
mm.set(0, 1, 3);
mm.set(0, 2, 5);
mm.set(1, 2, 2);
ca00.setPCMatrix(mm, choiceNames);
//=======================================
ca01 = ca0.get_ca(1);
mm = new PCMatrix(3);
mm.set(0, 1, 2);
mm.set(0, 2, 4);
mm.set(1, 2, 2);
ca01.setPCMatrix(mm, choiceNames);
//=======================================
ca10 = ca1.get_ca(0);
mm = new PCMatrix(3);
mm.set(0, 1, 1);
mm.set(0, 2, 3);
mm.set(1, 2, 2);
ca10.setPCMatrix(mm, choiceNames);
//=======================================
ca11 = ca1.get_ca(1);
mm = new PCMatrix(3);
mm.set(0, 1, 3);
mm.set(0, 2, 6);
mm.set(1, 2, 4);
ca11.setPCMatrix(mm, choiceNames);
//=======================================
ca12 = ca1.get_ca(2);
mm = new PCMatrix(3);
mm.set(0, 1, 4);
mm.set(0, 2, 5);
mm.set(1, 2, 5);
ca12.setPCMatrix(mm, choiceNames);
}
//=======================================
void Analyze()
 { goal.cal_PV_CR_recursive();
   goal.cal_weight_recursive();
 }
void Print_PV() {
ca00.printPV();
ca01.printPV();
ca10.printPV();
ca11.printPV();
ca12.printPV();
}
void Print_Choice() {
System.out.printf(" \n");
AHPNode.temp = 0.0;
goal.alternative_wieght_recursice("Build A");
System.out.printf("Build A= %7.3f\n", AHPNode.temp);
AHPNode.temp = 0.0;
goal.alternative_wieght_recursice("Build B");
System.out.printf("Build B= %7.3f\n", AHPNode.temp);
AHPNode.temp = 0.0;
goal.alternative_wieght_recursice("Build C");
System.out.printf("Build C= %7.3f\n", AHPNode.temp);
}
void Do_ahp_analysis() { 
Input_PCMatrix();
Analyze();
}

public static void main(String[] args) {
JMain jm = new JMain();
jm.Do_ahp_analysis();
jm.Print_PV();
jm.Print_Choice();  }
}

Answer 1

你写的代码，让别人来写注释？

Answer 2

得问写这几个类的人才能注释上去了。

Answer 3

明显楼主的代码是别的地方拷过来的自己看不懂才让别人写注释的吧

Answer 4

...
看到有七个留意 亏的我一顿兴奋
    有自己写代码让别人写注释的嘛
       我脑子烧坏了吧! 写程序都不用动脑子的？
       
     会得帮忙写下  谢谢
            别人等着用呢

Answer 5

是的我们都不动脑子  你给别人用关我们屁事

Answer 6

sb 说你了？ 你一直认为自己是猪吗？

Answer 7

     9楼
  你快点放弃编程吧
  就你这种理解能力 浪费时间

Answer 8

我们能力都不行，楼主靠你自己了！！

Answer 9

我们能力都不行，楼主靠你自己了！！

Answer 10

我们能力都不行，楼主靠你自己了！！