다른 내에서 생성 된 개체에 액세스

Question

내 문제는 간단하지만 나는 무엇을 위해 Google인지 알지 못합니다.

나는 어떻게 run.java 내에서 GLowestState에 액세스하기 위해 어떻게해야합니까, 기본적으로 그래서이

public class run { 
    //stuff 
    public static void main(String[] args) { 
     //stuff  
     Solver solver = new Solver(body,seeds); 
     solver.solve(); 
     LogTool.print("OUTPUT field of CLASS CREATED IN solver -- " + IDONTKNOWHOW,"notification"); 
    } 
} 
=========== 
public class Solver { 
    //stuff 
    public void solve() { 
     //stuff 
     GlobalState GLowestState = new GlobalState(this.Cur_state); 
    } 
} 

을하는 run.java이?

GLowestState가 싱글 톤으로 구현된다는 점에 차이가 있습니까?
아니겠습니까?
내 IDE에서 GLowestState.IDONTKNOWHOW에 대한 오류를 표시하므로 아무 것도 시도 할 수 없습니다. 더 많은 코드와

==============

업데이트 : GLowestState 만약

public class run { 
public static void main(String[] args) { 

     Voxel [][][] body = new Voxel[Config.xDIM][Config.yDIM][Config.zDIM]; 
     //stuff 

     Solver solver = new Solver(body,seeds);   

     LogTool.print("Initialized Solver Object!","notification"); 
     LogTool.print("Beginning Annealing...","notification"); 
     looper.solveSA(); 
     GlobalState GLS = looper.getGLowestState(); <--- NPE here 
     LogTool.print("GLC: " + looper.getGlobal_lowest_cost()+ " CURC: " + looper.getCur_cost(),"notification"); 
//  LogTool.print("GLS external: " + GLS,"notification"); 
     LogTool.print("SolveSA: Global Current Best Solution : " + looper.getGlobal_Lowest_state_string(),"notification"); 

========= 
public class Looper { 
    public static Voxel [][][] body; //Thobi hat das als ganz einfache Variable in seiner Loesermethode...nicht so OOP 
    public static Seed[] seeds = new Seed[Config.SAnumberOfSeeds]; 
    public double[] Cur_state = new double[Config.SAnumberOfSeeds]; 
    public double[] New_state = new double[Config.SAnumberOfSeeds]; // Do I even need this ? 
    public double[] Global_Lowest_state = new double[Config.SAnumberOfSeeds]; // Do I even need this ? 
    GlobalState GLowestState; 

    public Looper(Voxel [][][] body, Seed[] seeds) { 
     this.temperature = Config.StartTemp; 
     this.body = body; 
     this.seeds = seeds; 
       this.Cur_cost = Cur_cost; 
       this.New_cost = New_cost; 
       this.temperature = temperature; 
       this.Cur_state = Cur_state; 
       this.New_state = New_state; 
       this.Global_lowest_cost = Double.MAX_VALUE; 
       this.Global_Lowest_state = Global_Lowest_state; 
    } 

    public GlobalState getGLowestState() { 
     return GLowestState; 
    } 



     for (int ab = 0; ab < Config.NumberOfMetropolisResets; ab++) { 
      LogTool.print("==================== START CALC FOR OUTER ROUND " + ab + "=========================","notification"); 

      if (Config.SAverboselvl==1) { 
       LogTool.print("SolveSA: Cur_State Read before Metropolis : A)" + Cur_state[0] + " B) " + Cur_state[1] + " C) " + Cur_state[2],"notification"); 
       LogTool.print("Debug: GLS get 1: " + this.getGlobal_Lowest_state_string(),"notification"); 
      } 

      if (ab==0){ 
       this.initState(); 

       if (Config.SAverboselvl==1) { 
        LogTool.print("SolveSA: Cur_state after Initstate : A)" + Cur_state[0] + " B) " + Cur_state[1] + " C) " + Cur_state[2],"notification"); 
       } 
      } 

      setCur_cost(cost()); 

      /* [Newstate] with random dwelltimes */ 
      newState(); 
      if (Config.SAverboselvl==1) { 
       LogTool.print("SolveSA: New State before Metropolis: A)" + New_state[0] + " B) " + New_state[1] + " C) " + New_state[2],"notification"); 
      } 

      setNew_cost(cost()); 

      if (Config.SAverboselvl==1) { 
       LogTool.print("SolveSA: New Cost : " + New_cost,"notification"); 
      } 

      double random_double = RandGenerator.randDouble(0.01, 0.99); 

      /** 
       * MetropolisLoop 
       * @param Config.NumberOfMetropolisRounds 
      */ 

      for(int x=0;x<Config.NumberOfMetropolisRounds;x++) { 
    //   break; 
    //   LogTool.print("SolveSA Iteration " + x + " Curcost " + Cur_cost + " Newcost " + New_cost,"notification"); 
       if ((Cur_cost - New_cost)>0) { // ? die Kosten 

        if (Config.SAverboselvl>1) { 
         LogTool.print("Fall 1","notification"); 
        } 

        if (Config.SAdebug) {      
          LogTool.print("SolveSA: Metropolis NewCost : " + this.getNew_cost(),"notification"); 
          LogTool.print("SolveSA: Metropolis CurCost : " + this.getCur_cost(),"notification"); 
          LogTool.print("SolveSA Cost delta " + (Cur_cost - New_cost) + " ","notification"); 
        } 
          Cur_state = New_state; 
          Cur_cost = New_cost; 

        } else if (Math.exp(-(Cur_cost - New_cost)/temperature)> random_double) { 

         Cur_state = New_state; 
         Cur_cost = New_cost; 

         if (Config.SAdebug) { 
          LogTool.print("SolveSA: NewCost : " + this.getNew_cost(),"notification"); 
          LogTool.print("SolveSA: CurCost : " + this.getCur_cost(),"notification"); 
         } 

         if (Config.SAverboselvl>1) { 
          LogTool.print("Fall 2: Zufallsgenerierter Zustand traegt hoehere Kosten als vorhergehender Zustand. Iteration: " + x,"notification"); 
         } 
        } 

       temperature = temperature-1; 
       if (temperature==0) { 
        break; 
       } 

       random_double = RandGenerator.randDouble(0.01, 0.99); 
       newState(); 
       setNew_cost(cost()); 
      } 

      if (ab==9) { 
       double diff=0; 
      } 

//This is where the trouble happens - GlobalLoewst cost is set correctly and kept throughout the loops, GLowestState is always the last value of Cur_State (the most recent completed iteration. If smoothly running, that would be iteration 9 and inner iteration 99) @stackexchange 

      if (Cur_cost<Global_lowest_cost) { 
       this.setGlobal_lowest_cost(Cur_cost); 
       GlobalState GLowestState = new GlobalState(this.Cur_state); 
       LogTool.print("GLS DEDICATED OBJECT STATE OUTPUT -- " + GLowestState.getGlobal_Lowest_state_string(),"notification"); 
       this.setGlobal_Lowest_state(GLowestState.getDwelltimes()); 
       LogTool.print("READ FROM OBJECT OUTPUT -- " + this.getGlobal_Lowest_state_string(),"notification"); 
//    LogTool.print("DEBUG: CurCost direct : " + this.getCur_cost(),"notification");   
//    LogTool.print("Debug: Cur<global CurState get : " + this.getCur_state_string(),"notification"); 
//    LogTool.print("Debug: Cur<global GLS get : " + this.getGlobal_Lowest_state_string(),"notification"); 
//    this.setGlobal_Lowest_state(this.getCur_state(Cur_state)); 
//    LogTool.print("Debug: Cur<global GLS get after set : " + this.getGlobal_Lowest_state_string(),"notification");   
      } 
      LogTool.print("SolveSA: Iteration : " + ab,"notification"); 
      LogTool.print("SolveSA: Last Calculated New State/Possible state inner loop 99 : " + this.getNew_state_string(),"notification"); 
//   LogTool.print("SolveSA: Best Solution : " + this.getCur_state_string(),"notification"); 
      LogTool.print("SolveSA: GLS after: " + this.getGlobal_Lowest_state_string(),"notification"); 
      LogTool.print("SolveSA: NewCost : " + this.getNew_cost(),"notification"); 
      LogTool.print("SolveSA: CurCost : " + this.getCur_cost(),"notification");   
     } 
    } 

================= 

public final class GlobalState implements Comparable<Object>{ 
    private double[] dwelltimes; 
    private static GlobalState instance = null; 

    protected GlobalState(){ 
     // Exists only to defeat instantiation 
    } 

    public static GlobalState getInstance(){ 
     if (instance==null){ 
      instance = new GlobalState(); 
     } 
     return instance; 
    } 

    public GlobalState(double[] dwelltimes) { 
     this.dwelltimes = dwelltimes; 
    } 

    @Override 
    public int compareTo(Object o) { 
     throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates. 
    } 

    public double[] getDwelltimes() { 
     return dwelltimes; 
    } 

    public String getGlobal_Lowest_state_string() { 
     String Global_Lowest_state_string = new String(); 
     for (int cc = 0; cc < Config.SAnumberOfSeeds; cc++) { 
      Global_Lowest_state_string = Global_Lowest_state_string.concat(" " + cc + ") " + dwelltimes[cc]); 
      } 
     return Global_Lowest_state_string; 
    } 

    public void setDwelltimes(double[] dwelltimes_x) { 
     this.dwelltimes = dwelltimes_x; 
    } 

} 

Answer 1

는 당신이 정말로 그것을에 new를 호출 할 수있는 Singleton입니다 - - 잘 구현 된 Singleton이라고 가정합니다. 이 그럼 구현되면

당신은 다음과 같이 호출 :

GLowestState.getInstance(); 

또 다른 예 :

public class Solver { 
    private GlobalState GLowestState; 

    public void solve() { 
     GLowestState = new GlobalState(this.Cur_state); 
    } 

    public GlobalState getGLowestState() { 
     return GLowestState; 
    } 
} 

Answer 2

이런 식으로 뭔가를 할 수 싱글 톤이되기 위해서는 private 생성자와 newInstance 메서드가 필요합니다. 오히려 local variable보다 변수 instance variable 만든뿐만 아니라, 게터

public class run { 
    //stuff 
    public static void main(String[] args) { 
     //stuff 
     Solver solver = Solver.getInstance().solve(body,seeds); 
     LogTool.print("OUTPUT field of CLASS CREATED IN solver -- " + solver.getGLowestState(),"notification"); 
    } 
} 
=========== 
public class Solver { 

    private GlobalState gLowestState; 
    private static Solver singeltonSolver; 

    private Solver() { 

    } 

    public synchronized static Solver getInstance(){ 
     if(singeltonSolver== null) 
      singeltonSolver = new Solver(); 
     return singeltonSolver; 
    } 

    public void solve(SOmeType body,SOmeType seeds) { 
     //stuff 
     GlobalState GLowestState = new GlobalState(this.Cur_state); 
    } 

    public GlobalState getGLowestState() { 
     return gLowestState; 
    } 
} 

Answer 3

당신이 원하는 경우 찾기 :

GLowestState.getInstance().foo(); 

Answer 4

당신은 당신의 클래스의 내부 개체에 대한 getter를 구현해야와 필드 gloweststate 액세스를 만듭니다. 코드의 경우, 예입니다 GLowestState 이제 클래스의 인스턴스가 아닌 방법 solve()에서 지역 변수에 속하는 방법

public class Solver { 
    // stuff 
    GlobalState GLowestState; 

    public void solve() { 
     // stuff 
     GLowestState = new GlobalState(this.Cur_state); 
    } 
    public GlobalState getGLowestState(){ 
     return GLowestState; 
    } 
} 

알 수 있습니다. 이제

Solver solver = new Solver(body,seeds); 
solver.solve(); 
GlobalState GS = solver.getGLowestState(); 

를 호출 할 수 있습니다 그리고 변수 GS는 Solver 개체의 특정 인스턴스에 대한 GlobalState 변수를 계속합니다.

Answer 5

내가해야 할 일은 GlobalState에 싱글 톤을 보유하는 것입니다.

public enum GlobalState { 
    INSTANCE; 

    public String getValue() { ... } 
} 

그러나 Solver은 전역 상태로 엉망이되지 않는 것이 좋습니다.

public class Solver { 
    final String field; 
    //stuff 
    public Solver(int body, int seeds) { 
     //solve stuff here 
     this.field = "value"; 
    } 
} 

public class Run { 
    //stuff 
    public static void main(String[] args) { 
     //stuff 
     Solver solver = new Solver(body,seeds); 
     LogTool.print("OUTPUT field of " + solver.field); 
    } 
} 

Answer 6

은 여러 가지 방법으로 accomplisched 수 :

1 GlowestState 경우 특히 IT와 객체를 돌려 사용을 반환 할 경우에만 다음 solve() 관련이있다.

public GlobalState solve() { 
    GlobalState globalState = new GlobalState(this.Cur_state); 
    return globalState; 
} 

지금 당신은 그것을 액세스 할 수 있습니다

Solver solver = new Solver(body,seeds); 
GlobalState globalState = solver.solve(); 

2가 GlowestState 인스턴스를 확인하고 공개.

public GlobalState glowestState; 
public void solve() { 
    GLowestState = new GlobalState(this.Cur_state); 
} 

그럼 당신은 GLowestState을 얻을 수있는 게터를 사용

3 solver.glowestState

를 호출하여 얻을 수 있습니다.

private GlobalState glowestState; 
public void solve() { 
    glowestState = new globalState(this.Cur_state); 
} 

public getGlowestState() { 
    return GLowestState; 
} 

지금 당신은 그것을 GLowestState` 현재 해결() 메소드로 제한됩니다`의 범위 getGlowestState()