logica de negocios

LOGICA DE NEGOCIOS

Este paquete se encargará exclusivamente de las restricciones y validaciones requeridas por el software, estas restricciones deben ser tratadas de manera cautelosa ya que si no las tomamos en cuentas pueden causar daños en el software, haciendo que el software no pueda ejecutarse.

En este paquete hemos considerado necesario la creación de nueve clases, estas clases funcionaran de una manera que el usuario al momento de cometer un error el software se encargará de tratarlo, aquí se manejaran las excepciones que serán resueltas en un nivel superior, en la respectivas clases de las que son invocadas. Las excepciones serán manejadas en este software mediante las instrucciones Try y Catch.

Las clases a utilizar en este paquete son: GESTION NOTAS, CALCULADORA, APOSTFIJA, NOTAS, OPERACIONES, PILAS, PILARESULTADO, REEMPLAZO Y VALIDAR. A continuación haremos una descripción de las clases antes mencionadas

Clase Gestion Notas

Comenzaremos con la clase GESTION NOTAS, esta clase ha sido creada para manejar las excepciones antes mencionadas, aquí crearemos ocho métodos los cuales son: Consultar Alumnos, Consultar Cursos, Registrar Alumno, RegistrarCurso, ModificarAlumno, ModificarCurso, EliminarAlumno y EliminarCurso. Para la creación de estos métodos, ha sido necesario importar los paquetes: Entidades (Alumno y Curso) y Acceso a Datos (TablaAlumno y TablaCurso) además la librería de java, ya que también utilizaremos listas. Todos estos métodos mencionados anteriormente utilizaran las excepciones try y catch, cada uno de estos métodos se encargara de retornar los métodos creados por el paquete acceso a datos, tanto para alumnos y cursos los cuales son: Seleccionar, Insertar, Actualizar y eliminar.

Ahora explicaremos la clase Notas. En esta clase se ha debido importar los paquetes java.util.ArrayList, java.util.List. Además hemos declarado una variable tipo String llamada “frase”, y luego el respectivo constructor de la clase, esta variable(frase) será utilizada por los métodos de esta clase, los cuales son: almacen, cadanota, esnumero, posiciónoperador, igualnota, búsqueda y listaauxiliar.

Empezaremos explicando el método almacén, en el cual se ha utilizado la variable “frase”, la misma que será instanciada con la formula, luego hemos creado dos variables, una tipo String llamada “exa” (inicializada como vacía) y otra variable “examen” que será un vector tipo String (el cual será del tamaño de la frase ingresada), además de un contador “k” (inicializado en cero). En el respectivo código estamos inicializando un bucle con la instrucción “for” para recorrer la frase, luego con la instrucción condicional “if” se compara los caracteres de la frase recorrida para verificar si estos son letras entre A y Z. Si se cumple esta condición entonces se evalúa una nueva, también con “if” para verificar si la posición siguiente en la frase es un número (para esto se implemento el método esnumero), si esto se cumple entonces a la variable “exa” se le atribuye la subcadena de la frase desde la posición “i” hasta “posicionoperador(i)” (para esto se implemento el método posicionoperador) y luego al vector “examen” en la posición “k” le pasamos el valor de la variable “exa” y a la posición “i” la dejamos en “posicionoperador(i)-1”. De con cumplirse esta ultima condición (si no es número) entonces a la variable “exa” se le atribuye la subcadena de la frase desde la posición “i” hasta “i+1” y luego al vector “examen” en la posición “k” le pasamos el valor de la variable “exa”. De no cumplirse la primera condición (si la frase no contiene caracteres entre A y Z) entonces a la

variable “exa” le asignamos vacio (“”) y a la variable “k” la aumentamos en uno. Finalmente este método nos retornara la variable vector “examen”.

El método esnumero es para verificar si el carácter ubicado en una determinada posición es un número. Así este método tipo boolean nos devolverá un valor de verdad. En su código podemos ver que hemos creado la variable tipo carácter “numero”, luego con la instrucción condicional “if” verificamos que la variable “numero” este ente los valores 0 y 9. De tal forma si se cumple esta condición retornara el valor de verdad “true” y de no cumplirse retornara el valor “false”.

El método posicionoperador es para verificar la posición de un operador en la frase. Así este método de tipo “int” nos retornara un valor tipo entero (“a”). Hemos creado las variables tipo enteras “posicion” y “a”, de las cuales hemos asignado a la variable “a” el tamaño de la frase. En su código podemos ver que hemos inicializado un bucle con la instrucción “for”, en el cual al contador “i” le hemos asignado la variable entera “posicion”, luego recorremos la frase, y mediante una instrucción condicional “if” verificamos que la subcadena de la frase en la posición (i,i+1) pueda ser igual a “+, -, *, /, (, )” para luego asignarle a la variable “a” la posición “i”, y hacer un quiebre de bucle con la instrucción “break”. Finalmente el método nos retornara la variable “a”.

El método cadanota es para verificar los caracteres de la frase que forman una nota. Así este método que es una “lista” nos devolverá la lista (“resultado”). Hemos creado una lista tipo array “resultado” y un vector tipo String “examen”, al cual le hemos asignado el vector del método almacen. En su código podemos ver que hemos inicializado un bucle con la instrucción “for”, para recorrer la frase y mediante una instrucción condicional “if” verificamos que el vector “examen” en la posición “i” sea diferente de nulo(que no se encuentre vació), si se cumple esta condición entonces se agrega “examen” en la posición “i” a la lista tipo array “resultado”. Finalmente retornaremos la lista “resultado”.

El método búsqueda es para realizar una determinada búsqueda de una nota en la lista, este método se esta declarando como booleano, aquí hemos dado como parámetros una lista tipo String “lista” y una variable String “nota”, además se esta creando una variable tipo boolean “a” (inicializada en false). En su código podemos ver que hemos inicializado una instrucción “for” para recorrer la lista y mediante una instrucción condicional “if” se esta comparando si una nota ingresada es igual a la que se encuentra en la posición de la lista, si se cumple esta condición a la variable “a” se le asigna el valor de verdad “true”. Finalmente el método nos retornara la variable “a”.

El método listaauxiliar, el cual se esta declarando como una lista tipo string, aquí hemos dado como parámetro un entero “posicion”, además se esta declarando una lista tipo String “resultado”, a la cual le asignamos el método cadanota y también una lista tipo array “aux”. En su código podemos ver que hemos inicializado una instrucción “for” para recorrer la lista “resultado” y mediante una instrucción condicional “if” se esta comparando si el contador “i” es igual al de la variable posicion, de no ser igual entonces agregara a la lista “auxi” la lisa resultado en la posicion “i”. Finalmente este método retornara la lista “aux”.

El método igualnotas es para verificar si existen notas iguales dentro de la lista auxiliar, en este método se hace un llamado a busqueda y listaauxiliar. Aquí se ha creado una lista tipo String “resultado”, a la cual le asignamos el método cadanota y también una lista tipo array “aux”. en el codigo podemos ver que hemos inicializado una instrucción “for” para recorrer la lista “resultado”, luego hemos asignado a la variable “aux” el método listaauxiliar con el parámetro indicador de posicion “i”, y mediante una instrucción condicional “if” hemos llamado al método busqueda para verificar si el valor de la lista aux para resultado.get(i) es igual a “true”, de cumplirse esta condición el valor de la variable “notasiguales” le asignamos el valor “true” y hacemos un quiebre de ciclo con la instrucción “break”. Finalmente este método nos retornara la variable “notasiguales”.

Siguiendo con las clases ahora explicaremos la clase operaciones. . En esta clase no se ha importado ningún paquete. Hemos declarado tres variables tipo double “x, y, respuesta” y una variable tipo String llamada “letras”, además de su respectivo constructor. Hemos considerado la creación de cuatro métodos, los cuales son: suma, resta, producto, division. En todos estos metodos se realiza una operación respectiva(+, -, *, /) y retorna una variable respuesta. Como todos tienen la misma logica vamos a explicar solo uno de ellos.

El método suma se encargara de realizar el proceso de suma entre las variables “x” y “y”, para luego asignarlo a una variable resultado y finalmente retornando esta.

Ahora veremos la clase calculadora, en esta clase hemos importado los paquetes Entidades.Nota, java.util.ArrayList;, java.util.List y seran usado según la necesidad de los metodos, los cuales son: EsCorrecto, DeterminarTiposEvaluacion y Calcular.

Empezaremos explicando el metodo EsCorrecto, este metodo es de tipo boolean y tiene como parámetro la variable tipo String “Expresion” . Básicamente el metodo consistira en retornarnos que la expresión esta correcta.

Seguiremos con el metodo DeterminarTiposEvaluacion, el cual es una lista tipo String con su parámetro “Expresion”. Se ha creado una variable lista tipo String “resultado”, luego se ha creado el objeto “obj” de la clase notas y se le ha dado como parámetro la variable “Expresion”, después a la variable resultado se le ha

asignado el objeto “obj” que ha llamado al metodo cadanota, de la clase notas. Finalmente este metodo nos retornara la lista “resultado”.

Finalmente veremos el método Calcular, este método es de tipo Double y se le ha asignado los parámetros “Expresion” y “Notas”. Se ha inicializado una variable “resultado” de tipo double con el valor 0,0 para ser reconocida. Luego se ha creado una lista tipo String “notitas” en la cual se almacenaran todas las notas del modelo de la tabla, tambien se han creado una variable tipo double “a” inicializada en 0. En el código podemos observar que hemos inicializado una instrucción “for” para recorrer la lista Notas, luego con una instrucción condicional “if” verificamos si la nota es menor que cero o mayor que 20, si se cumple esta condición agregamos a la lista “notitas” el valor 0, de no cumplirse entonces agregamos la nota a la lista “notitas”.Teniendo la lista notitas, creamos un objeto “ennumeros” de la clase remplazo con los parámetros “notitas” y ”Expresion” , luego le asignamos a una variable String “num” el objeto ennumeros con el metodo mejorado e imprimimos la variable “num”. Siguiendo el codigo se ha creado el objeto “posfija” de la clase aposfija y se le ha asignado a la variable String “pos” este objeto con el metodo resultado para luego imprimir la variable “pos”. Finalmente se ha creado el objeto “res” de la clase pilaresultado con el parámetro “pos” para luego asignar a la variable “resultado” el objeto “res” con el metodo PilaVacia2 convertido a tipo de dato double, para al final retornar esta variable.

CLASE VALIDAR

En esta clase se comprueba la formula si esta semántica y sintácticamente correcta, para empezar se ha declarado una variable global “frase” la cual se utilizara para instanciarla por medio del constructor:

public validar(String frase) { this.frase = frase;}

Después del constructor se ha creado una clase llamada validación en la cual retornará si la frase esta correctamente escrita o no, en este caso luego se llamara este método para verificar si la formula esta correctamente escrita:

public boolean validacion(){ if(hay()==true){ if(parentesis()==true){ pila Obj =new pila(frase); if(Obj.Pila()==true){ return conparentesis(); }else{ return false; } } else{ return sinparentesis(); } }else{ return false; } }

En este método se ha llamado a otras funciones como “hay()”, la cual devuelve si es que la frase tiene operadores y notas, además el método “paréntesis” devuelve si hay una cantidad par de paréntesis, para luego crear un objeto “Obj” de la clase “Pila()” la cual contiene una pila con sus correspondientes métodos que devuelve si la frase esta correctamente escrita con sus paréntesis:

public boolean Pila(){ boolean retornar=true; for (int i = 0; i < frase.length(); i++) { if(frase.substring(i,i+1).equals("(")){ agregar(1); }

if(frase.substring(i,i+1).equals(")")){ if(pop()==true){ }else{ retornar=false; break; } } } return retornar; }

Luego colocamos una sentencia “if ” que divide cuando hay y no hay paréntesis : “conparentesis()” y “sinparentesis()”:En estos dos métodos se usara el proceso de recursividad por cuestiones didácticas explicare el primer método “sinparéntesis()”, en esta podemos mencionar que hemos considerado un algoritmo recursivo que llama a diversos métodos: private boolean EsLetra(String expresion, int posicion){} =>>>En este método inicializa la recursividad puesto que en la expresión debe o bien comenzar con una letra o bien con un numero no puede comenzar de otra forma, este método llama a los siguientes. Luego aumenta la posición en que se encuentra y llama a los métodos recursivos como son que en el caso de que en la posición siguiente puede haber un operador, un numero, y un terminador el cual le hemos asignado un “;” para poder terminar el bucle, los siguientes métodos muestran lo que le continua por ejemplo:

Los siguientes métodos recursivos private boolean EsOperador(String expresion, int posicion){} =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son:

Una letra o un numero con su respectivo método.

private boolean EsNumero(String expresion, int posicion){} =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son:

Un numero, un punto, un operador un terminador con su respectivo método.

private boolean EsPunto(String expresion,int posicion){} =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son:

Es un numero con su respectivo método.

private boolean EsTerminador(String expresion, int posicion){} =>>>Este Método devuelve recursivamente verdad o falsedad si al que le continua son:

En este caso el “;”.

En el método de conparentesis() igual se generan los métodos pero teniendo en cuenta por ejemplo que a un paréntesis cerrado no le puede seguir ni una nota ni un numero, y que necesariamente debe ser un operador

CLASE NOTA

En este clase igual que las demás clases se crea un constructor para después instanciarlo este clase nota esta compuesta por dos métodos principales el primero almacen() que devuelve todas las notas que se encuentran en la frase en este caso las notas de la formula en un Array y el otro método convierte este array en una lista para su mejor uso.

public String[] almacen(){ frase=frase.toUpperCase(); String exa=""; String examen[] = new String[frase.length()]; int k=0; for (int i = 0; i < frase.length(); i++) { if( frase.charAt(i) == 'A' || frase.charAt(i) == 'B'||

frase.charAt(i) == 'C' || frase.charAt(i) == 'D'|| frase.charAt(i) == 'E' || frase.charAt(i) == 'F'|| frase.charAt(i) == 'G' || frase.charAt(i) == 'H'|| frase.charAt(i) == 'I' || frase.charAt(i) == 'J'|| frase.charAt(i) == 'K' || frase.charAt(i) == 'L'|| frase.charAt(i) == 'M' || frase.charAt(i) == 'Ñ'|| frase.charAt(i) == 'N' || frase.charAt(i) == 'O'|| frase.charAt(i) == 'P' || frase.charAt(i) == 'Q'|| frase.charAt(i) == 'R' || frase.charAt(i) == 'S'|| frase.charAt(i) == 'T' || frase.charAt(i) == 'U'|| frase.charAt(i) == 'V' || frase.charAt(i) == 'W'|| frase.charAt(i) == 'X' || frase.charAt(i) == 'Y'|| frase.charAt(i) == 'Z'){ if(esnumero(frase.charAt(i+1))){ exa=exa+frase.substring(i, posicionoperador(i));//;i+2); examen[k]=exa; //i=i+1; i=posicionoperador(i)-1; } else{ exa=exa+frase.substring(i, i+1); examen[k]=exa; } } else{ exa=""; k=k+1; } } return examen; } public List<String> cadanota(){ List<String> resultado = new ArrayList(); String examen[] = almacen(); for (int i = 0; i < frase.length(); i++) { if(examen[i]!=null){ resultado.add(examen[i]); } } return resultado; }

La algoritmo utilizado en el primer método es el de crear un array “examen[]” de la longitud de la “frase”, luego se recorre la frase si encuentra una letra que la almacene en el array desde esta posición hasta la posición del siguiente operador para lo cual hemos utilizado el método posición operador()

public int posicionoperador(int posicion){ int a=frase.length();

for (int i = posicion; i < frase.length(); i++) { if(frase.substring(i, i+1).equals("+")||frase.substring(i, i+1).equals("-")||frase.substring(i, i+1).equals("*")|| frase.substring(i, i+1).equals("/")||frase.substring(i, i+1).equals("(")||frase.substring(i, i+1).equals(")")){ a=i; break; } } return a; }

Para dar una mejor efectividad al programa he creido realizar tres funciones mas: igualnotas(), busquedad(List<String>lista, String nota), listaauxiliar(int posicion), maximo():

public boolean igualnotas(){ boolean notasiguales=false; List<String> resultado =cadanota(); List<String> aux = new ArrayList(); for (int i = 0; i < resultado.size(); i++) { aux=listaauxiliar(i); if(busquedad(aux,resultado.get(i))==true){ notasiguales=true; break; } } return notasiguales; }

En este método creamos una lista del método realizado con anterioridad “cadanota()” luego recorreremos esta lista y por cada nota crearemos una lista auxiliar con el método listaauxiliar() con el fin de con el método busquedad(aux, resultado.get(i)) devuelva si exite una lista igual.

Luego finalmente con el método máximo() se ha realizado un testeo con la nota 20 se ha creado una lista y se ha efectuado con la formula:

public boolean maximo(){ double veinte; List<String> resultado =cadanota(); List<String> aux =new ArrayList(); for (int i = 0; i < resultado.size(); i++) { aux.add("20"); } remplazo ennumeros=new remplazo(aux,frase); String num=ennumeros.mejorado();

aposfijaa posfija=new aposfijaa(); String pos=posfija.resultado(num);

pilaresultado res=new pilaresultado(pos); veinte=Double.parseDouble(res.PilaVacia2()); if(veinte==20){ return true; }

else{ return false; } }

Como se puede observar se ha creado un objeto con la clase remplazo la cual con la lista de notas de 20 ha sido remplazado en la formula por las notas,Luego se ha instanciado un objeto con la clase aposfijaa y este a su vez en pilaresultado() el cual efectuara la formula hecha números en posfija y posteriormente su resultado.Si el resultado es 20 significa que la formula esta correctamente escrita de no ser así esta incorrecta.

CLASE PILARESULTADO

En esta clase se resuelve la formula escrita en posfija para el resultado final de la operación:

public String PilaVacia(){

String operando1; String operando2; String simbolo; double valor=0; String acumulador="";

for (int i = 0; i < frase.length(); i++) {

simbolo=frase.substring(i, i+1);

if(operando(simbolo)==true){ acumulador=acumulador+simbolo; }else{ if(simbolo.equals(" ")){ if(!acumulador.equals("")){ agregar(acumulador); acumulador=""; }

}else{ if(!simbolo.equals(" ")&&vec.length>1){

operando1 = pop();operando2 = pop();

Operaciones op= new

operaciones(Double.parseDouble(operando2),Double.parseDouble(operando1)); f (simbolo.equals("+")) { valor=op.suma(); }

if (simbolo.equals("-")) { valor=op.resta(); }

if (simbolo.equals("*") ){ valor=op.producto(); }

if (simbolo.equals("/")) { valor=op.division(); }

agregar(Double.toString(valor)); } }

}}

}En este método recorremos la expresión si encuentra un operando este que lo vaya acumulando.Si no, si encuentra un vacío que extraiga de la pila los operadores y según su operación ejecutar con estos operadores la operación correspondiente.

Al Final se retornará el único elemento de la pila que será el resultado de la operación, que vendría hacer el promedio.

CLASE APOSFIJA

Esta clase llamada posfija se encargará de convertir la formula de inflija a postfija, que es mejor trabajarlo así.

Empezaremos por crear un dato de tipo string llamado encontradas que será una variable de tipo global y nos devolverá el resultado evaluado o convertido.

Luego creamos el método resultado que se encargará de devolvernos el resultado de tipo string y este método recibe de parámetro expresion. Hemos importado la pila de la librería java para facilitarnos su uso, ya que habrá dos pilas una donde guardara los números y la otra los operadores, entonces creamos un objeto llamado PilaNumeros y PilaOperadores respectivamente de la clase Stack() . La expresion la pasamos a mayúsculas y la guardamos en “exp”, declaramos un dato de tipo string llamado fragmento se encargará de guardar el fragmento de texto que se esté utilizando en el momento (ya sea un número, un operador, etc.), un dato de tipo int llamad “posicion” y “tamaño”, se encargaran de la posicion del carácter que se esta procesando actualmente y del tamaño del texto que se procesa en este momento respectivamente y un dato de tipo int llamado “cont” que se encargará de contar, indica el número de caracteres que se sacan del string en un momento indicado, este no puede ser más de cuatro (la función con más caracteres).

public class aposfija El nombre de nuestra clase

private String encontadas;

public String resultado(String expresion){

Stack PilaNumeros=new Stack();

Stack PilaOperadores= new Stack();

String expr=expresion.toLowerCase();

String fragmento;

int pos=0, tamaño=0;.

int cont=1;

String funciones []={"1 2 3 4 5 6 7 8 9 0 ( ) x + - * /"}

String parentesis="(";

int anterior=0;

Comenzamos a recorrer la expresion, luego validamos si la suma de pos mas cont sea menor o igual al tamaño de la expresion y utilizamos el indexOf, hace que a cada elemento del array llamado funciones si hay el número de ocurrencias es por que será diferente de “-1”, si no, quiere decir que no hay ocurrencias; si esto es correcto entonces tamaño es igual a cont y este se irá incrementando.

for (int i = 0; i < expr.length(); i++) {

tamano=0;

cont=1;

if (tamano==0 && cont<=1){ //Este while revisa si el pedazo del texto sacado concuerda con algo conocido

if(pos+cont<=expr.length() && funciones[cont-1].indexOf(expr.substring(pos,pos+cont))!=-1){

tamano=cont;

}

cont++;

}

Si encontró algo, de tamaño uno, y otra condición donde llama al método EsNumero, que le pasas como parámetro el recorrido de la expresion desde pos hasta po+tamaño, si lo es, se encargara de sacarlo por completo. Dentro de la condición inicializamos el fragmento como vacío que es el acumulador, ya que será ahí donde se guardará el número sacado anteriormente con la instrucción do while, que haga mientras siga siendo número o punto que vaya concatenando y siga aumentando el pos, mientras pos sea menor que el tamaño de la expresión o sea igual a un punto o una coma. Luego hace el fragmento lo agrega a la pila de números, anterior se le asigna uno y el contador disminuye en uno.

Pero si no es número quiere decir que un operador, la cual puede ser una suma, resta, multiplicación o división; llama al método extraeOperadores que se encargará de que si el operador tiene menor prioridad del operador que se encuentra en la pila entonces va ir sacando los operadores de mayor prioridad hasta entrarlo en la pila, hay que tener en cuenta que va tener que llamar al método prioridad para que realice el cambio sucesivo hasta cuando encuentre uno que sea menor o igual.

Luego este método llamara al método extraerOperador se encargara de se sacar el operador que se va evaluar, si encuentra un operador saca dos elementos de la pila numeros y los guarda con el operador que fue evaluado a la PilaNumeros, pero hemos tenido que crear un objeto de la clase string debido a que vamos a concatenar los operadores con los espacios en blanco (Numeros.push(new String(a+" "+b+" "+operador)); ) y sino saca un elemento y lo concatena con el operador (Numeros.push(new String(a+" "+operador)).

if(tamaño==1){ //Si encontró algo de tamaño uno

if(EsNumero(expr.substring(pos, pos+tamaño))){ //Si es un número se encarga de sacarlo completo

fragmento="";

do{

fragmento=fragmento+expr.charAt(pos);

pos++;

}while(pos<expr.length() && Numero(expr.substring(pos,pos+tamano)) || expr.charAt(pos) == '.' || expr.charAt(pos) == ',' ));

PilaNumeros.push(new String(fragmento));

anterior=1;

pos--;

}else if (expr.charAt(pos)=='+' || expr.charAt(pos)=='*' || expr.charAt(pos)=='/' ){

ExtraeOperadores(PilaNumeros, PilaOperadores, expr.substring(pos, pos+tamano));

anterior=2;

}else if (expr.charAt(pos)=='-'){ //Si es una resta

if(anterior==0 || anterior==2 || anterior==3){

PilaNumeros.push(new String("-1"));

ExtraeOperadores(PilaNumeros, PilaOperadores, "*");

}else{//

ExtraeOperadores(PilaNumeros, PilaOperadores, " -");

}

anterior=2;

}else if (expr.charAt(pos)=='('){

if (anterior==1 || anterior == 4){

ExtraeOperadores(PilaNumeros, PilaOperadores, "*");

}

PilaOperadores.push(new String("("));

anterior=3;

}else if (expr.charAt(pos)==')'){

while(!PilaOperadores.empty() && parentesis.indexOf(((String)PilaOperadores.peek()))==-1){

ExtraeOperador(PilaNumeros, PilaOperadores);

}

if(!((String)PilaOperadores.peek()).equals("(")){

PilaNumeros.push(new String(((String)PilaNumeros.pop()) + " " + ((String)PilaOperadores.pop())));

}else{

PilaOperadores.pop();

}

anterior=4;

}

}

pos+=tamano;

}

//Procesa al final

while(!PilaOperadores.empty()){ //Saca todos los operadores mientras la pila no esté vacía

ExtraeOperador(PilaNumeros, PilaOperadores);

}

encontadas = ((String)PilaNumeros.pop()); //Se obtiene el resultado final

return encontadas; //Se devuelve el resultado evaluado

}

En este método se crea una tercera pila con el fin evaluar la expresion y dividirla por morfemas luego que la divide recorre los tokens, cada token representa un numero o un operador, en caso de ser un operador va a ejecutar la operación en caso q no llena la pila en la pila en la operación realizada y si no la llena en el Token.

public double f(String expresionParseada, double x) {

Stack pilaEvaluar = new Stack(); // Pila de doubles para evaluar

double a, b; //Estos valores son los que se van sacando de la pila de doubles

StringTokenizer tokens=new StringTokenizer(expresionParseada); //La expresión partida en tokens

String tokenActual; //El token que se procesa actualmente

while(tokens.hasMoreTokens()){ //Haga mientras hayan más tokens

tokenActual=tokens.nextToken();

if(tokenActual.equals("+")){//Si es una suma se sacan dos números y se suman

b=((Double)pilaEvaluar.pop()).doubleValue();

a=((Double)pilaEvaluar.pop()).doubleValue();

pilaEvaluar.push(new Double(a+b));

}else if(tokenActual.equals("-")){//Si es resta se sacan dos valores y se restan (así con todos los operadores)



pilaEvaluar.push(new Double(a-b));

}else if(tokenActual.equals("*")){//Multiplicación



pilaEvaluar.push(new Double(a*b));

}else if(tokenActual.equals("/")){//División



pilaEvaluar.push(new Double(a/b));

}else{//si es otra cosa tiene que ser un número, simplemente se mete en la pila

pilaEvaluar.push(Double.valueOf(tokenActual));

}

}

a=((Double)pilaEvaluar.pop()).doubleValue(); //El valor a devolver

return a;

}

Este método se va encargar de devolver la prioridad que será de tipo entero ya sea “0”, “1” ó “-1”ya que la multiplicación y división tienen prioridad sobre el “+” mas y gggg “-“.

private int prioridad(char s) {

if (s=='+' || s=='-') //Si es una suma o una resta devuelve cero

return 0;

else if (s=='*' || s=='/') //Si es multiplicación, división o resto de división devuelve uno

return 1;

return -1; //Si no fue nada de lo anterior devuelve -1

}

Este método se va encargar de devolver si es número o no, si lo es retornará true, sino false y recibirá como parámetro un s de tipo String.

private boolean EsNumero(String s) {

boolean como = true;

if (s.equals("0") || s.equals("1") || s.equals("2") || s.equals("3") || s.equals("4") || s.equals("5") || s.equals("6") || s.equals("7") || s.equals("8") || s.equals("9")) //Si el caracter está entre 0 y 9 (si es un número) {

return como;

}else

como=false;

}

return como;

}

private void ExtraeOperadores(Stack PilaNumeros, Stack PilaOperadores, String operador){

//Todas las funciones que se manejan como paréntesis de apertura

final String parentesis="(";

//mientras (While) la pila no esté vacía, el operador que sigue no sea un paréntesis de apertura, la longitud del operador sea uno (para que sea un operador), y la prioridad indique que tiene que seguir sacando elementos

while(!PilaOperadores.empty() && parentesis.indexOf((String) PilaOperadores.peek()) ==-1 && ((String)PilaOperadores.peek()).length()==1 && prioridad(((String)PilaOperadores.peek()).charAt(0))>=prioridad(operador.charAt(0))){

ExtraeOperador(PilaNumeros, PilaOperadores); //Saca el siguiente operador

}

PilaOperadores.push(operador);//Al final mete el nuevo operador luego de sacar todo lo que tenía que sacar.

}

private void ExtraeOperador(Stack Numeros, Stack operadores) {

String operador,

String a;

String b;

String operadores="+ - * / "; //Lista de los operadores

operador= (String) operadores.pop(); //Saca el operador que se debe evaluar

if(operadores.indexOf(operador)!=-1){ //Si es un operador saca dos elementos de la pila y guarda la operación

b=(String)Numeros.pop();

a=(String)Numeros.pop();

Numeros.push(new String (a+" "+b+" "+ operador));

}else{ //==>Sino sólo saca un elemento

a=(String)Numeros.pop();

Numeros.push(new String(a+" "+operador));

}

}//sacaOperador

logica de negocios

Documents