Usuario:ManuelRomero/accion

De WikiEducator
Saltar a: navegación, buscar



AccionCalculadora

Es la clase que implementa las acciones que ha de realizar la calculadora
  • Tiene dos vías de comunicacione
  1. sirve para realizar las acciones que EstadoCalculadora le solicita
  2. VentanaCalculadora despues de cada entrada y de que estadoCalculadora indique de que modo hay que modificar el atributo resultado recoge este valor y lo almacena en la pantalla
Lleva un atributo que representa el resultado en un momento dado de la calculadora que es lo que aparece en la pantalla

Código fuente

package calculadora;
 
 
 
/*
 * Esta clase lo que hace es obtener calculo que es el string que se visualizará en un momento 
 * dado en la calculadora
 * */
public class AccionCalculadora {
	private String resultado;
	private OperacionReal operacion = new OperacionReal();
	private OperacionRacional operacionR = new OperacionRacional();
	final int REAL =0;
	final int RACIONAL=1;
 
 
	public AccionCalculadora(){
		resultado ="";
	}
 
	/**
	 * Pone en resultado una cadena de caracteres que le pasamos como parámetro
	 * Posteriormente la interfaz retomará este valor para visualizarlo por pantalla
	 * @param e 
	 */
	public void actualiza (String  e){
 
		resultado = e;
		//MRM Pendiente Quitar ceros inecesarios en cada operando
	}
	public String quitaCeros(String e){
 
		return "";
 
	}
	public void cambioSignoOp1(String e){
		if (e.charAt(0)=='-')
			resultado = e.substring(1);
		else
			resultado = "-"+e;
	}
	public void cambiarSignoOp2(String e,int tipo){
		int operador ;
		operador = getPosicionOperador (e,tipo);
		if (e.contains("("))
			   resultado=e.substring(0,e.indexOf('('))+e.substring(e.indexOf('(')+2,e.indexOf(')'));
    	else
    		   resultado=e.substring(0,operador+1)+"(-"+e.substring(operador+1)+")";
	}
	public void quitarCaracterOp1(String s){
		int pos = s.length();
		resultado = s.substring(0,pos-1);
	}
	public void quitarCaracterOp2(String s){
		int pos = s.length();
		if (s.contains("(")){
			resultado = s.substring(0,pos-2)+")";
			System.out.println("En quita Caracter "+resultado);
		}else {
			resultado = s.substring(0,pos-1);
		    System.out.println("En quita Caracter "+resultado);
		}
	}
	public void quitarSignoOp2(String s){
		// x + -(ss)  ==> x+ss
		int inicio = s.indexOf('(');
		int fin = s.length();
		resultado = s.substring(0,inicio)+s.substring(inicio+2,fin-1); 
		System.out.println("en quitarSignoOp2 "+resultado);
	}
	/**
	 *  en un segundo parámetro si añadimos un número y hay paréntesis, añado el valor dentro del paréntesis
	 *  ej.  p=8+(-87) e=5   retorno 8+(-875)
	 * @param p el valor de la pantalla
	 * @param e la entrada
	 * @return la cadena actualizada
	 */
	public void actulizaRetrocesoConPosibleParentesis(String p){
		int pos =p.length();
		if (p.contains("("))
			resultado = p.substring(0,pos-2)+")";
		else
			resultado = p.substring(0,pos-1);
		}
	public void actualizaNumOp2Decimal(String p, char e){
		int pos =p.length();
		if (p.contains(")"))
			resultado = p.substring(0,pos-1)+e+")";
		else
			resultado =p+e;
 
 
	}
	public void actualizarConPosibleParentesis(String p, String e){
 
		int pos = p.length();
		if (p.contains(")")){
			resultado=(p.substring(0,pos-1)+e+")");
		    System.out.println("Resultado "+resultado);
		}
		else
			resultado = p+e;
		}
	/**
	 * Toma un String que representa una operacion,
	 *  y cambia el signo del segundo operando
	 *  poniéndole un paréntesis.
	 *
	 * 		p = 76-52 ==> 76-(-52)
	 * @param p ==> Es la expresión que contiene los valores sobre los que quiero actual
	 * @param op ==> Indica el operando sobre el que quiero actual.
	 */
    public void actualizaCambioSigno(String p){
   		//Suponemos segundo operando
   		if (p.contains(")")){//Estaba en segundo operando negativo y hay que pasar a positivo
   			// 98 + (-85) ==> 98 + 85  o 9/6+(-8/7) o 9/6+(-8) o 9/6+(-8/)
   		    // 98 + (-85) ==> 98 + 85  o 9.6+(-8.7) o 9.6+(-8) o 96+(-0.)
 
   			int pos;
   			pos=p.indexOf('(');
   			System.out.println("1 "+p.substring(0,pos));
   			System.out.println("21 "+p.substring(pos+1,p.length()-1));
   			resultado = p.substring(0,pos)+p.substring(pos+2,p.length()-1);
   		}
   		else{//Estaba en segundo operando positivo y
   			 //hay que pasarlo a negativo ==> paréntesis
   			 //95+89 ==> 95+(-89)
   			int pos = getPosicionOperador(p,0);
   			//System.out.println("Operacion "+p+"operador en posicion "+pos);
   			resultado = p.substring(0,pos+1)+"(-"+p.substring(pos+1,p.length())+")";
   			//System.out.println("En accion "+resultado);
    		}
    }
    /**
     * Retorna la posición donde se ubica un operando del array especificado 
     * quitando el primer caracter por si el primer operando es 0
     * -87.7-(-77.98) ==> Retorna 5 , ya que 
     *                   el operador menos está en la posición 5 
     * @param operacion
     * @return
     * 
     * 
     * 
     */
    private int getPosicionOperador(String operacion, int tipo){
    	int p=0;
		p=operacion.indexOf('+');
		if (p != -1)
		   return p;
		p=operacion.indexOf('*');
		if (p != -1)
		   return p;
		p=operacion.indexOf('%');
		if (p != -1)
		   return p;
		p=operacion.indexOf(':');
		if (p != -1)
		   return p;
		if (tipo == REAL){
			p=operacion.indexOf('/');
			if (p != -1)
		        return p;
		}
		//En caso de haber salido antes
		//Seguro que el operador es el -
		//Directamente quito el primer caracter por si es negativo en primer número
		p=operacion.substring(1).indexOf('-');
		return p;
   }
	public void addResultado(char e){
			resultado +=e;
	}
	public void calcula(String valorActual, int tipo){
		if (tipo==REAL){
	 		System.out.println("1En calcula con operacion "+valorActual);
	  	    operacion.setOperacion(valorActual);
		    resultado=operacion.resultado().toString();
		}else{
			System.out.println("2En calcula con operacion "+valorActual);
			operacionR.setOperacion(valorActual);
			resultado=operacionR.resultado().toString();
			System.out.println("Valor de "+valorActual +"Resultado = "+resultado);
		}
 
	}
	public void actualizaCalculo(String c){
	    resultado+=c;
	    System.out.println("Calculo"+resultado);
   }
	public String  getResultado(){
		return resultado;
	}
 
	public void limpiaPantalla(){
		resultado="";
	}
	//Implementar este método
	/**
	 * Nos devuelve el número de caracteres del operador 2
	 * La idea es que si el op2 =0  o un sólo dígito me devuelva 0 caracteres, en otro caso  1
	 * 
	 * 0/ ==> 0 caracteres
	 * (-0/) ==> 0 caracteres
	 * * 0. ==> 0 caracteres
	 * (-0.) ==> 0 caracteres
	 * n ==>  0
	 * -(n) ==> 0 
	 * Otra situación retorna 1
	 */
	public int caracteresOp2(String s, int tipo){
		int pos = getPosicionOperador(s,tipo);
		String op2 = s.substring(pos);
		if (tipo == RACIONAL){
			if (op2.contains("(")){
				System.out.println("Op2 negativo...");
				if (op2.length()==3||(op2.length()==2& op2.charAt(2)==0)){
					System.out.println("... negativo y con el 0");	
 				    return 0;
				}
				else{
					System.out.println("... negativo y diferente del 0");
					return (1);
				}
			}
			else
				if (op2.length()==2 &op2.charAt(0)=='0')
					return 0;
				else
					return op2.length()-2;
		}else //calculadora real
			if (op2.contains("(")){
				if (op2.contains("."))
					if (op2.length()==6) // +(-5.)
						return 0; //2º op con un sólo dígito
					else	
						return 1;
				else
					if (op2.length()==5) // +(-6)
						return 0; //2º op con un sólo dígito
					else	
						return 1;
			}
			else{
				if (op2.contains("."))
					if (op2.length()==3) // +5.
						return 0; //2º op con un sólo dígito
					else	
						return 1;
				else
					if (op2.length()==2) // +6
						return 0; //2º op con un sólo dígito
					else	
						return 1;
			}
}
	public void cambiaSignoResultado(){
		String s= this.resultado;
		if (resultado.charAt(0)=='-')
			this.resultado = s.substring(1);
		else
			this.resultado = "-"+s;
	}
}
Obtenido de «https://es.wikieducator.org/index.php?title=Usuario:ManuelRomero/accion&oldid=8169»