[JAVA]: Conversione di un applet in una classe semplice

[peppespe]

C'è la possibilità di convertire un Applet Java in una Classe semplice. Sul libro dela Sun ho visto solo l'operazione inversa. Se è possibile mi potete indicare qualche esempio? Grazie.

[alka]

Si parla per caso di decompilazione, in soldoni? :master:

[peppespe]

no, il mio quesito è posto sulla conversione di un listato di un applet in una classe "normale" java.

[alka]

Originariamente inviato da peppespe
no, il mio quesito è posto sulla conversione di un listato di un applet in una classe "normale" java.

In tal caso, non sarebbe sufficiente rimuovere la derivazione dalla classe JApplet (e affini)?

[peppespe]

a questo ci avevo pensato anche io, ma mi sono trovato in dubbio sul seguente applet contenuto nel file rng.java :

import java.awt.Graphics;
import java.applet.Applet;
import java.awt.Color;

public class rng extends java.applet.Applet{

  Color col1,col2,col3;
  double piaw=3.14159265358979;
  int Naw;
  int takaaw,habaaw,orikaeshi;
  int kaw,iaw,jaw,i,br2,law,haw;
  String NS,habaS,takaS;
  double Nd,takad,habad,xx,yy,dd,mind;
  
  /**
  	converte una stringa in un double
  */
  public double dou(String dous){
    double dou1;
    dou1 = (Double.valueOf(dous)).doubleValue();
    return dou1;
  }
  
  /**
  	genera un numero casuale
  */
  public double randaw(){
    double rand1aw;
    rand1aw=Math.random();
    return rand1aw;
  }
  
  //EX COSTRUTTORE
  public void init(){
    col1=Color.black;
    col2=Color.yellow;
    col3=Color.white;
    takaS=getParameter("takap");	//lunghezza
    habaS=getParameter("habap");	//altezza
    NS=getParameter("Np");		//numero di nodi
    habad=dou(habaS);	//converte la stringa altezza in un numero double
    takad=dou(takaS);	//converte la stringa lunghezza in un numero double
    Nd=dou(NS);		//converte la stringa numero di nodi in un numero double
    if(Nd==20){		//se il numero di nodi è 20 genera un numero di nodi casuali
      Nd=4+46*randaw();
    }
    habaaw=(int)habad;	//effettua un cast in intero dell'altezza precedentemente convertita in double
    takaaw=(int)takad;	//effettua un cast in intero della lunghezza precedentemente convertita in double
    Naw=(int)Nd;	//effettua un cast in intero del numero di nodi precedentemente convertito in double
  }
  
  double x1aw[]=new double[100];
  double y1aw[]=new double[100];
  double w1aw[]=new double[100];
  double x2aw[]=new double[100];
  double y2aw[]=new double[100];
  double w2aw[]=new double[100];
  int xaw[]=new int[100];
  int yaw[]=new int[100];
  int waw[]=new int[100];
  double saw[]=new double[100];
  String sssaw[]=new String[100];
  
  /**
  	restituisce un valore double rappresentate la potenza di aaw^baw
  	@param aaw rappresenta la base
  	@param baw rappresenta la base
  */
  public double jouaw(double aaw,double baw){
    double jou1aw;
    jou1aw=Math.pow(aaw,baw);
    return jou1aw;
  }
  
  /**
  	restitusce un valore double rappresentante l'arcoseno di atasw
  	@param atasw rappresenta un valore di tipo double del quale ci si vuole calcolare l'arcoseno
  */
  public double arcsinaw(double atasw){
    double artn1saw;
    artn1saw=Math.asin(atasw);
    return artn1saw;
  }
  
  /**
  	restitusce un valore double rappresentante l'arcotangente di ataw
  	@param atasw rappresenta un valore di tipo double del quale ci si vuole calcolare l'arcoseno
  */
  public double artnaw(double ataw){
    double artn1aw;
    artn1aw=Math.atan(ataw);
    return artn1aw;
  }
  
  /**
  	restituisce la distanza tra la differeza di due punti
  	@param d1 rappresenta un valore di tipo double identicato come un punto
  	@param d2 rappresenta un valore di tipo double identicato come un punto
  	@param d2 rappresenta un valore di tipo double identicato come un punto
  	@param d3 rappresenta un valore di tipo double identicato come un punto
  	@param d4 rappresenta un valore di tipo double identicato come un punto
  */
  public double d(double d1,double d2,double d3,double d4){
    double dw;
    dw=jouaw(jouaw(d3-d1,2.0)+jouaw(d4-d2,2.0),0.5);
    return dw;
  }
  
  /**
  	gestisce la sequenza dei nodi che si incontrano con uno heap
  */
  void heapaw(double he1aw[],double he2aw[],double he3aw[],int NNaw){
    int kkaw,kksaw,iiaw,jjaw,mmaw;
    double b1aw,b2aw,b3aw,c1aw,c2aw,c3aw;
    kksaw=(int)(NNaw/2);
    for(kkaw=kksaw;kkaw>=1;kkaw--){
      iiaw=kkaw;
      b1aw=he1aw[iiaw-1];b2aw=he2aw[iiaw-1];b3aw=he3aw[iiaw-1];
      while(2*iiaw<=NNaw){
        jjaw=2*iiaw;
        if(jjaw+1<=NNaw){
          if(he1aw[jjaw-1]<he1aw[jjaw]){
            jjaw++;
          }
        }
        if(he1aw[jjaw-1]<=b1aw){
          break;
        }
        he1aw[iiaw-1]=he1aw[jjaw-1];he2aw[iiaw-1]=he2aw[jjaw-1];he3aw[iiaw-1]=he3aw[jjaw-1];
        iiaw=jjaw;
      }//wend
      he1aw[iiaw-1]=b1aw;he2aw[iiaw-1]=b2aw;he3aw[iiaw-1]=b3aw;
    }//next kk
    for(mmaw=NNaw-1;mmaw>=1;mmaw--){
      c1aw=he1aw[mmaw];c2aw=he2aw[mmaw];c3aw=he3aw[mmaw];
      he1aw[mmaw]=he1aw[0];he2aw[mmaw]=he2aw[0];he3aw[mmaw]=he3aw[0];
      iiaw=1;
      while(2*iiaw<=mmaw){
        kkaw=2*iiaw;
        if(kkaw+1<=mmaw){
          if(he1aw[kkaw-1]<=he1aw[kkaw]){
            kkaw++;
          }
        }
        if(he1aw[kkaw-1]<=c1aw){
          break;
        }
        he1aw[iiaw-1]=he1aw[kkaw-1];he2aw[iiaw-1]=he2aw[kkaw-1];he3aw[iiaw-1]=he3aw[kkaw-1];
        iiaw=kkaw;
      }//wend
      he1aw[iiaw-1]=c1aw;he2aw[iiaw-1]=c2aw;he3aw[iiaw-1]=c3aw;
    }//next mm
  }
  
  public void paint(java.awt.Graphics g){
    g.setColor(col1);
    g.fillRect(1,1,habaaw,takaaw);
    xx=0.0;
    yy=0.0;
    g.setColor(col2);
    for(kaw=1;kaw<=Naw;kaw++){
      x1aw[kaw-1]=randaw()*(habaaw-30)+15;
      y1aw[kaw-1]=randaw()*(takaaw-30)+15;
      xaw[kaw-1]=(int)(x1aw[kaw-1]+0.5);
      yaw[kaw-1]=(int)(y1aw[kaw-1]+0.5);
      sssaw[kaw-1]=""+waw[kaw-1];
      g.fillOval(xaw[kaw-1]-2,yaw[kaw-1]-2,4,4);
      //g.drawString(""+w1aw[kaw-1],xaw[kaw-1],yaw[kaw-1]);
    }
    g.setColor(col3);
    for(kaw=0;kaw<Naw-1;kaw++){
        for(law=kaw+1;law<Naw;law++){
            mind=d(x1aw[kaw],y1aw[kaw],x1aw[law],y1aw[law]);
            br2=0;
            for(haw=0;haw<Naw;haw++){
                if(haw!=kaw && haw!=law){
                    dd=d(x1aw[kaw],y1aw[kaw],x1aw[haw],y1aw[haw]);
                    if(d(x1aw[law],y1aw[law],x1aw[haw],y1aw[haw])>dd){
                        dd=d(x1aw[law],y1aw[law],x1aw[haw],y1aw[haw]);
                    }
                    if(dd<mind){
                        br2=1;
                        break;
                    }
                }
            }//h
            if(br2==0){
                g.drawLine(xaw[kaw],yaw[kaw],xaw[law],yaw[law]);
            }
        }//l
    }//k
    g.setColor(col2);
    g.drawString("N="+Naw,15,15);
  }
  
}//rng

per convertirlo in una classe che non usi un applet ho iniziato a realizzare la seguente ossatura, contenuta nel file di prova denominato rngTest.java :

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
	Classe di Prova per la classe rng
*/
public class rngTest {

  public static void main(String argv[]) {
	rngFrame frame = new rngFrame();	//istanzia un oggetto SimpleFrame
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	//quando viene chiuso il frame si esce dal programma
	frame.show();	//Visualizza la finestra
  }//main
}//SimpleFrametest

/**
	Crea un frame di ampiezza WIDTH ed altezza HEIGHT, acquisendo la risoluzione video
	lo presenta a partire ad 1/4 delle sue coordinate.
*/
class rngFrame extends JFrame{
	//Costruttore
	public rngFrame(){
		
		//prende le dimensioni dello schermo
		
		Toolkit kit = Toolkit.getDefaultToolkit();
		//restituisce le dimensioni dello schermo del client come oggetto Dimension
		Dimension screenSize = kit.getScreenSize();
		int screenHeight = screenSize.height;	//ampiezza dello schermo
		int screenWidth = screenSize.width;
		setSize(WIDTH, HEIGHT);	//Inposta la grandezza del frame
		setLocation(screenWidth/4, screenHeight/4);	//fa partire il frame da 1/4 del video
		setResizable(false);	//imposta che il frame non può essere ridimensionato
		Image img = kit.getImage("grafo.gif"); //imposta l'icona ed il titolo
		setIconImage(img);
		setTitle("RNG");
		
		//aggiunge un pannello al frame
		
		rngPanel panel = new rngPanel();
		Container contentPane = getContentPane();
		contentPane.add(panel);
	}//SimpleFrame
	
	public static final int WIDTH = 500;	//Ampiezza
	public static final int HEIGHT = 350;	//Altezza
}//rngFrame

/**
	Un pannello che visualizza un messaggio
*/
class rngPanel extends JPanel{
	
	public void paintComponent(Graphics g){
		super.paintComponents(g);
		
		g.drawString("RNG Panel", MESSAGE_X, MESSAGE_Y);
	}
	
	public static final int MESSAGE_X = 75;
	public static final int MESSAGE_Y = 100;
}//rngPanel

Ora sulla base di tale struttura ho pensato di realizzare le seguenti fasi:
1. il corpo del main va integrato con quanto vi è nel file html che inizializza l'applet

<html>
<title>RNG</title>
	<body>
		<applet code="rng.class" height="350" width="500">
		<param name="takap" value="350">
		<param name="habap" value="500">
		<param name="Np" value="20">
		</applet>
	</body>
</html>

ovviamente con richieste in input dei valori 'takap', 'habap' e 'Np'. In tal contesto verrà instanziato un oggetto rngFrame(takap, habap, Np).
Il punto cruciale sta nel sostituire il costruttore dell'applet init() con il costruttore della classe rnfFrame.
Inoltre il corpo della procedura

public void paint(java.awt.Graphics g){
    .........
  }

va sostituito in

class rngPanel extends JPanel{
	
	public void paintComponent(Graphics g){
		super.paintComponents(g);
		
		...........
	}
....
}//rngPanel

???