Hola necesito crear un applet, que sera un conversor de dinero muy simple, Os pongo en situacion, tan solo se pide una cantidad, y se pide moneda de origen (entre tres: euro, dolar o yen) y finalmente se muestran los resutados en las 3 divisas, como digo algo muy simple.
El applet tiene que aproveche este codigo 'conversor.java', y deberá tener un campo de texto (TextField) en el que el usuario podrá escribir una cantidad, un selector (Choice) con el que el usuario podrá elegir el tipo de moneda que representa la cantidad en el campo de texto, un botón para calcular los resultados y unas etiquetas donde se escribirán las diferentes cantidades en las diferentes monedas. Al applet deberá pasarle la información del tipo de cambio por los <param ...> del applet. Pues bien imagino que no es muy dificil pero no tengo mucha idea de trabajar con applet solo lo basico alguien podria indicarme como crear el codigo del applet????
Pongo el codigo hecho en java que debera aprovechar:
Tambien si alguien me podria ayudar en la funcion que he señalado en negrita, necesitaria leer los valores de cambio desde un fichero, sería mediante randomAccessFile, pues tendria que escribir los valores de cambio necesarios en el fichero, y luego saber usarlos en el codigo, multiplicando estos valores por la cantidad introducirla. No creo que sea dificil pero no se como haceder a cada parte, y luego usarla.
import java.io.*;
public class conversor{
/**
* Los operadores que reconocerá. e= euro, d=dolar, y =yen.
*/
private static final String[] operadores = {"e","d","y"};
/**
* El operador. Debe ser uno de los elementos de operadores
*/
private String operador;
/**
* El valor a convertir.
*/
private double entrada;
/**
* El resultado final en euros.
*/
private double resultadoE;
/**
* El resultado final en dolar.
*/
private double resultadoD;
/**
* El resultado final en yen.
*/
private double resultadoY;
/**
* El constructor único sin parámetros.
*/
public conversor() {
limpiar();
}
/**
* Reinicia valores.
*/
public void limpiar() {
entrada=0.0;
resultadoE=0.0;
resultadoD=0.0;
resultadoY=0.0;
operador= null;
}
/**
* Determina si la cadena s es un operador para este conversor.
* Los operadores son "e", "d" y "y"
* @return true si s es uno de los operadores y false en caso contrario.
*/
public static boolean esOperador(String s) {
for (int i=0;i<operadores.length;i++) {
if (operadores[i].equals(s)) {
return true;
}
}
return false;
}
/**
* Analiza la cadena s, la convierte en un double y asigna el valor a entrada.
* Lanza una excepción si s no tiene formato de número decimal.
*/
public void entrarValor(String s) throws NumberFormatException {
entrada=Double.valueOf(s).doubleValue();
}
/**
* Define el operador activo como op si la cadena op es un operador
* del conversor y lanza una excepción en caso contrario.
*/
public void definirOperador(String op) throws Exception {
for (int i=0;i<operadores.length;i++) {
if (operadores[i].equals(op)) {
operador=op;
return;
}
}
throw new Exception("operador desconocido");
}
/**
* Realiza la operación usando los valores actuales de
* operador y entrada, y pone almacena los resultados.
*/
public void realizarOperación(){
if (operador.equals("e")) {
resultadoE = entrada;
resultadoD = entrada * 2;
resultadoY = entrada * 4;
} else if (operador.equals("d")) {
resultadoE = entrada * 2;
resultadoD = entrada;
resultadoY = entrada * 4;
} else if (operador.equals("y")){
resultadoE = entrada * 2;
resultadoD = entrada * 4;
resultadoY = entrada;
}
}
/**
* Devuelve el valor actual de entrada.
*/
public String entrada() {
return Double.toString(redondear(entrada));
}
/**
* Devuelve el valor actual de resultado en euros.
*/
public String resultadoE() {
return Double.toString(redondear(resultadoE));
}
/**
* Devuelve el valor actual de resultado en dolares.
*/
public String resultadoD() {
return Double.toString(redondear(resultadoD));
}
/**
* Devuelve el valor actual de resultado en yen.
*/
public String resultadoY() {
return Double.toString(redondear(resultadoY));
}
/**
* Devuelve el valor actual de operador.
*/
public String operador() {
return operador;
}
/**
* Redondea x a 8 decimales.
*/
private static double redondear(double x) {
double pres=100000000.0;
return (Math.round(x*pres)/pres);
}
/**
* Crea un objeto conversor,
* Mientras no ocurra una excepción:
* pide al usuario entrada de un OPERADOR,
* pide al usuario un NUMERO,
* realiza la operación,
* escribe el resultado en la consola.
*/
public static void main(String[] args) {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
conversor C=new conversor();
try {
while(true){
System.out.print("\nMoneda de origen: ");
C.definirOperador(br.readLine());
if (C.esOperador(C.operador())) {
System.out.print("Cantidad a convertir: ");
C.entrarValor(br.readLine());
}
C.realizarOperación();
System.out.println("\nresultado en EUROS= "+C.resultadoE());
System.out.println("resultado en DOLARES= "+C.resultadoD());
System.out.println("resultado en YENS= "+C.resultadoY());
System.out.println("");
}
} catch (Exception e) {
System.out.println(e);
}
}
}
