Compra

El código de la clase Questionnaire que compro es la siguiente

Questionnaire

/**
* Clase Questionnaire
*/

//Se importan las librerías necesarias para el midlet que se le envía y
//los componentes gráficos
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

//Se importa la librería necesaria para manejar vectores
//(listas usadas como arreglos dinámicos)
import java.util.*;
/**
* @author Christian Sarmiento
*/
public class Questionnaire extends Form implements CommandListener{
//----------------------Atributos de la clase-----------------------------\\
private String name; //Identificador del cuestionario
private String fileLocation; //Ruta del archivo de texto
private int numberOfQuestions; //Numero de preguntas en el cuestionario
private int numberOfCorrectAnswers; //Numero de respuestas correctas
private MIDlet theMidlet; //El midlet desde donde se aplica el cuestionario
private String content; //La descripción del cuestionario
//(Es la que se coloca después de la etiqueta
//<questionnaire> en el archivo de texto)
private Vector questions; //Lista de objetos Question (Las preguntas
//del cuestionario)
private String textOfFile; //Contenido del archivo de texto
private TextReader reader; //Lector de archivos txt (Es el la clase del
//Doctor Ayala "UdlaTextFileResource")
private Displayable originalDisplayable; //Desplegable que estaba en pantalla
//en el momento en que se aplica
//el cuestionario
private Display display;
private Command nextQuestion;
private Command previousQuestion;
private Command endQuestionnaire;
private Command cancel;
//-----------------------Variables globales-------------------------------//
/**
* Son variables de control que, entre otros métodos, son utilizadas en el
* método "commandAction" al cual no se le pueden cambiar los parámetros,
* por lo que es necesario declararlas en esta zona.
*/

private int actualCorrectAnswers; //Lleva el control del numero de respuestas
//correctas. Es necesaria para que en caso
//de que el cuestionario sea cancelado,
//no se modifique el número de respuestas
//correctas anterior a la aplicación de
//este.
private int currentQuestion; //Indicador de la pregunta que se encuentra
//actualmente activa
//-------------------------------Constructor------------------------------\\
public Questionnaire(String aName, String aFileLocation, MIDlet aMidlet){
//Se llama al constructor de la clase padre
super(aName);
//Guardamos los parámetros enviados
theMidlet = aMidlet;
fileLocation = aFileLocation;
name = aName;
//Inicializamos la lista suponiendo que existe al menos una pregunta e
//indicando que en caso de que la estructura este llena y se quiera agregar
//una pregunta mas, aumente su longitud en 1:
//Vector(Tamaño inicial, Aumento de tamaño en caso de ser necesario)
questions = new Vector(1,1);
//Leemos el archivo de texto
reader = new TextReader(fileLocation);//Se prepara para leer el archivo
textOfFile = reader.getContent();//Lee el archivo y regresa solo el texto
//como una cadena de caracteres (String)
//Leemos el texto obtenido anteriormente y creamos los objetos necesarios
//a partir de este.
readTextOfFile();
//Construir comandos
nextQuestion = new Command("Siguiente", Command.OK, 1);
previousQuestion = new Command("Atrás", Command.BACK, 1);
endQuestionnaire = new Command("Fin", Command.OK, 3);
cancel = new Command("Cancelar", Command.CANCEL, 1);
//Agregamos los comandos en los desplegables correspondientes
setCommands();
//Agregamos el texto de bienvenida del cuestionario
if(content.length() > 0){
//Si existe información del cuestionario la añadimos
this.append("Estas a punto de contestar un cuestionario sobre:\n\n " + content);
}
else{
//Si no existe, lo indicamos
this.append("No hay información disponible sobre el cuestionario");
}
//inicializamos el numero de respuestas correctas en 0 ya que apenas se
//está construyendo el objeto y lógicamente sabemos que no se ha contestado
//pero pueden acceder a resultados antes de hacerlo
numberOfCorrectAnswers = 0;
}//Fin
//---------------------------------------------------------------------------------\\
//-------------------------------Métodos Públicos----------------------------------\\
//---------------------------------------------------------------------------------\\
//-----------------------------Método "apply"-----------------------------\\
//Aplica el cuestionario
public void apply(){
//Obtener el display del midlet que fue enviado como parámetro en la
//construcción del objeto (utilizando la clase correctamente, el
//midlet en que fue creado)
display = Display.getDisplay(theMidlet);
//Obtener el desplegable activo del midlet para poder regresarlo al
//finalizar el cuestionario
originalDisplayable = display.getCurrent();
//Se indica que actualmente no existe alguna pregunta activa
currentQuestion = 0;
//El número de respuestas correctas en este momento se coloca en 0
actualCorrectAnswers = 0;
//Se coloca este desplegable en pantalla (solo contiene la bienvenida del
//cuestionario)
display.setCurrent(this);
}//Fin
//-------------------------Método "getName"-------------------------------\\
public String getName(){
return name;//Regresa el identificador del cuestionario
}//Fin
//--------------------Método "getNumberOfQuestions"-----------------------\\
public int getNumberOfQuestions(){
return numberOfQuestions;//Regresa el número de preguntas del cuestionario
}//Fin

//-------------------Método "getNumberOfCorrectAnswers"-------------------\\
public int getNumberOfCorrectAnswers(){
return numberOfCorrectAnswers;//Regresa el numero de respuestas correctas de
//la última vez que el cuestionario fue contestado
//en su totalidad. 0 si no ha sido contestado
}//Fin

//-------------------------Método "toString()"----------------------------\\
/**
* Overwrite del método toString de la clase Object
*/
public String toString(){
return content;//Regresa el nombre (información) del cuestionario
}//Fin
//---------------------------------------------------------------------------------\\
//-------------------------------Métodos Privados----------------------------------\\
//---------------------------------------------------------------------------------\\
//------------------------Método "setCommands"-----------------------------\\
private void setCommands(){
//Variables del método
//Question es un objeto que extiende de Form, por lo tanto es un desplegable
Question aQuestion;//Pregunta a la que se le agregaran los comandos
//Agregamos los comandos a las preguntas del cuestionario
for(int i = 0; i < numberOfQuestions; i = i + 1){//Para todas las preguntas
//Obtenemos la pregunta correspondiente a la iteración actual
aQuestion = getQuestion(i);
//Agregamos el comando para ir a la pregunta anterior (o a la forma
//de bienvenida si es la primera pregunta)
aQuestion.addCommand(previousQuestion);
//Si es la última pregunta agregamos el comando para finalizar el cuestionario
if(i == numberOfQuestions - 1){
aQuestion.addCommand(endQuestionnaire);
}
//Si no es la ultima agregamos el comando para ir a la pregunta siguiente
else{
aQuestion.addCommand(nextQuestion);
}
//Se indica que el control de sus comandos lo hará esta clase
aQuestion.setCommandListener(this);
}//Fin del for
//Agregamos los comandos de la forma de bienvenida
this.addCommand(nextQuestion);
this.addCommand(cancel);
this.setCommandListener(this);
}//Fin
//------------------------Método readTextOfFile---------------------------\\
private void readTextOfFile(){
//Variables del método
int textPosition;//Indica la posición de un determinado caracter
//Al iniciar el lector no tenemos ninguna pregunta agregada
numberOfQuestions = 0;
//Buscamos el final la primera etiqueta (la cual según el formato es
//<questionnaire>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;//String.indexOf(Caracter buscado)
//Regresa la posición del primer
//caracter que coincide
textOfFile = textOfFile.substring(textPosition);//String.substring(inicio de la nueva cadena)
//Buscamos el inicio de la siguiente etiqueta
textPosition = textOfFile.indexOf('<');
//El texto antes de esta etiqueta es el nombre (información) del cuestionario
content = textOfFile.substring(0,textPosition).trim();//String(inicio, final)
//String.trim() borra
//los espacios en blanco
//al inicio y final de
//la cadena original
//Borramos todo lo anterior a la ultima etiqueta encontrada, según el
//formato esta será <question> o </questionnaire>
textOfFile = textOfFile.substring(textPosition);
//Ahora buscamos todas las preguntas en lo que queda del texto (ver que
//al momento no se han eliminado ninguna etiqueta <question>
findQuestions();//Busca todas las etiquetas <question> y crea los objetos
//Question correspondientes
}//Fin
//------------------------Método "findQuestions"--------------------------\\
private void findQuestions(){
//Como se elimino todo lo anterior a la ultima etiqueta <question> o
//</questionnaire> encontrada, el caracter en la posición 1 (iniciando
//en la posición 0) será 'q' o '/' respectivamente, si es '/' termino de
//crear todas las preguntas del archivo, de lo contrario se encontró una
//pregunta más y tendrá que crearla
while(textOfFile.charAt(1) != '/'){
createQuestion();//Crea un objeto Question y elimina todo lo referente
//a la pregunta encontrada hasta la etiqueta siguiente
//a </question> la cual según el formato tiene que
//ser otra <question> o un </questionnaire>
}
}//Fin
//-------------------------Método "createQuestion"------------------------\\
private void createQuestion(){
//Variables del método
Question addingQuestion;//Pregunta que se va a crear
int textPosition;//Indica la posición de un determinado caracter
//Indicamos que ya encontramos una pregunta mas
numberOfQuestions = numberOfQuestions + 1;
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es <question>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el inicio de la siguiente etiqueta
textPosition = textOfFile.indexOf('<');
//El texto antes de esta etiqueta es el texto de la pregunta
//Question(identificador, Texto de la pregunta)
addingQuestion = new Question("Pregunta " + numberOfQuestions ,textOfFile.substring(0, textPosition).trim());
//Borramos todo lo anterior a la ultima etiqueta encontrada, según el
//formato esta será <answer> o </question>
textOfFile = textOfFile.substring(textPosition);
//Buscamos las respuestas que están antes de la siguiente etiqueta
//</question> que son las posibles respuestas a la pregunta recién creada
findAnswers(addingQuestion);//findAnswers(una pregunta); encuentra todas
//las respuestas y las agrega en la pregunta
//que se le envía como parámetro, también borra
//de la cadena todo lo referente a las preguntas
//encontradas
//Agregamos la pregunta ya totalmente formada en nuestro vector de preguntas
addQuestion(addingQuestion);
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es </question>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el inicio de la primera etiqueta en lo que queda del texto (la
//cual según el formato es <question> o </questionnaire>) y borramos todo
//lo anterior a ella para que sea lo primero que se encuentre en el texto
textPosition = textOfFile.indexOf('<');
textOfFile = textOfFile.substring(textPosition);
}//Fin
//-----------------------Método "findAnswers"-----------------------------\\
private void findAnswers(Question aQuestion){
//Como se elimino todo lo anterior a la ultima etiqueta <answer> o
//</question> encontrada, el caracter en la posición 1 (iniciando
//en la posición 0) será 'a' o '/' respectivamente, si es '/' termino de
//crear todas las respuestas de la pregunta, de lo contrario se encontró una
//respuesta más y tendrá que crearla
while(textOfFile.charAt(1) != '/'){
createAnswer(aQuestion);//Crea un objeto Answer y elimina todo lo referente
//a la respuesta encontrada hasta la etiqueta siguiente
//a </answer> la cual según el formato tiene que
//ser otra <answer> o un </question>, también agrega
//la respuesta encontrada en la pregunta correspondiente
}
}//Fin
//-------------------------Método "createAnswer"--------------------------\\
private void createAnswer(Question aQuestion){
//Variables del método
int textPosition;//Indica la posición de un determinado caracter
String answer;//En texto de la respuesta encontrada
String isCorrectText;//El texto entre <isCorrect> y </isCorrect> de la
//respuesta encontrada
boolean isCorrect;//Indica si es correcta o no la respuesta encontrada
Answer actualAnswer;//Respuesta que se va a crear y agregar
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es <answer>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el inicio de la siguiente etiqueta
textPosition = textOfFile.indexOf('<');
//El texto antes de esta etiqueta es el texto de la respuesta
answer = textOfFile.substring(0, textPosition).trim();
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es <isCorrect>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el inicio de la siguiente etiqueta
textPosition = textOfFile.indexOf('<');
//El texto antes de esta etiqueta indica si es o no correcta
isCorrectText = textOfFile.substring(0, textPosition).trim();
//Si el texto es "true" isCorrect será 'true', si no lo es, según el
//formato solo puede ser "false" con lo que el resultado será 'false'
isCorrect = isCorrectText.equalsIgnoreCase("true");//String.equalseIgnoreCase(texto)
//true si el texto es igual a la
//cadena original, no afectan las
//diferencias entre mayúsculas y
//minúsculas
//Creamos el objeto Answer con los resultados anteriores
actualAnswer = new Answer(answer, isCorrect);//Answer(texto, es o no correcta)
//Agregamos la respuesta a la pregunta indicada
aQuestion.addAnswer(actualAnswer);
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es </isCorrect>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el final la primera etiqueta en lo que queda del texto (la
//cual sabemos que es </answer>) y la borramos
textPosition = textOfFile.indexOf('>') + 1;
textOfFile = textOfFile.substring(textPosition);
//Buscamos el inicio de la primera etiqueta en lo que queda del texto (la
//cual según el formato es <answer> o </question>) y borramos todo
//lo anterior a ella para que sea lo primero que se encuentre en el texto
textPosition = textOfFile.indexOf('<');
textOfFile = textOfFile.substring(textPosition);
}//Fin
//-----------------------Método "getQuestion"-----------------------------\\
private Question getQuestion(int index){
return (Question)questions.elementAt(index);//Regresa la pregunta del vector
//de preguntas en la posición
//indicada
}//Fin
//-------------------------Método "addQuestion""--------------------------\\
private void addQuestion(Question theQuestion){
questions.addElement(theQuestion);//Agrega la pregunta indicada en la
//ultima posición del vector
}//Fin
//--------------------------Método "commandAction"------------------------\\
public void commandAction(Command c, Displayable d){
//Variables del método
boolean correct;//Indica si la respuesta seleccionada es correcta
int selectedAnswer;//Indica cual es la respuesta seleccionada
//Si el comando es "nextQuestion" presentamos la siguiente pregunta
if(c == nextQuestion){
//Si existe actualmente una pregunta desplegada
if(currentQuestion > 0){
//Verificamos si la respuesta seleccionada es la correcta
selectedAnswer = this.getQuestion(currentQuestion - 1).getSelectedIndex();
correct = this.getQuestion(currentQuestion - 1).getAnswer(selectedAnswer).isCorrect();
if(correct){
//Si es correcta aumentamos nuestro contador de respuestas correctas
actualCorrectAnswers = actualCorrectAnswers + 1;
}
}
//Desplegamos la siguiente pregunta (o la primera si no hay pregunta
//desplegada actualmente)
currentQuestion = currentQuestion + 1;
display.setCurrent(this.getQuestion(currentQuestion - 1));
}
//Si es "previousQuestion" colocamos la pregunta anterior o el desplegable
//de bienvenida si es la primera pregunta
else if(c == previousQuestion){
//Indicamos que estamos en la pregunta anterior
currentQuestion = currentQuestion - 1;
//Si la anterior no es una pregunta, mostramos la bienvenida
if(currentQuestion == 0){
display.setCurrent(this);
}
//Si es una pregunta
else{
//Verificamos si la respuesta era correcta
selectedAnswer = this.getQuestion(currentQuestion - 1).getSelectedIndex();
correct = this.getQuestion(currentQuestion - 1).getAnswer(selectedAnswer).isCorrect();
if(correct){
//Si lo era restamos una respuesta correcta que volverá a ser
//evaluada al terminar la pregunta
actualCorrectAnswers = actualCorrectAnswers - 1;
}
//Desplegamos la pregunta (o la bienvenida si es la pregunta "0")
display.setCurrent(this.getQuestion(currentQuestion - 1));
}
}
//Si es "cancel" terminamos el cuestionario sin salvar el resultado
else if(c == cancel){
//Mostramos el desplegable que estaba antes de aplicar el cuestionario
display.setCurrent(originalDisplayable);
}
//Si no es ningún otro, el comando es "endQuestionnaire" y termina el
//el cuestionario salvando el resultado
else{
//Verificamos si la respuesta seleccionada es la correcta
selectedAnswer = this.getQuestion(currentQuestion - 1).getSelectedIndex();
correct = this.getQuestion(currentQuestion - 1).getAnswer(selectedAnswer).isCorrect();
if(correct){
////Si es correcta aumentamos nuestro contador de respuestas correctas
actualCorrectAnswers = actualCorrectAnswers + 1;
}
//Salvamos el número de respuestas correctas
numberOfCorrectAnswers = actualCorrectAnswers;
//Mostramos el desplegable que estaba antes de aplicar el cuestionario
display.setCurrent(originalDisplayable);
}
}//Fin
}//Fin de la clase Questionnaire

*************************************
       Desarrollada por Christian Sarmiento
*************************************

********************** Mi MIDlet *********************
/**

* ProyectoMidlet
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class ProyectoMidlet extends MIDlet implements CommandListener
{
//ATRIBUTOS
private Display display;
private List listaMenu;
private Command comandoSalir;
private Command comandoAceptar;
private Form formaPreguntas;

//Cosntructor
public ProyectoMidlet()
{
display = Display.getDisplay( this );
comandoSalir = new Command("Salir",Command.OK,1);
comandoAceptar = new Command("Aceptar",Command.OK,1);
formaPreguntas = new Form("Preguntas");
}//ProyectoMidlet

//MÉTODOS
public void startApp()
{
listaMenu = new List("Selecciona una opción", Choice.IMPLICIT);
listaMenu.append("Culturas", null);
listaMenu.append("Presidentes", null);
listaMenu.append("Historia", null);
listaMenu.addCommand(comandoSalir);
listaMenu.addCommand(comandoAceptar);
listaMenu.setCommandListener(this);
display.setCurrent(listaMenu);
}//startApp

public void pauseApp()
{
}//pauseApp

public void destroyApp(boolean unconditional)
{
}//destroyApp

public void commandAction (Command c, Displayable d)
{
if (c == comandoSalir)
{
try
{
destroyApp(true);
notifyDestroyed();
}//try
catch(Exception e)
{
System.out.println(e.toString());
}//catch
}//if
else if (c == comandoAceptar)
{
Questionnaire questionnaire = new Questionnaire(
listaMenu.getString(listaMenu.getSelectedIndex()),
"/Cuestionario"+(listaMenu.getSelectedIndex()+1)+".txt",
this);
questionnaire.apply();
String s="preguntas="+questionnaire.getNumberOfQuestions()+", correctas="+questionnaire.getNumberOfCorrectAnswers();
Ticker ticker= new Ticker(s);
listaMenu.setTicker(ticker);
}//if
}//CommandAction

public Display getDisplay()
{
return display;
}//getDisplay

public Form getFormaPreguntas()
{
return formaPreguntas;
}//getFormaPreguntas

public List getListaMenu()
{
return listaMenu;
}//getListaMenu
}//ProyectoMidlet

Primer proyecto

*********************MIDlet**********************
/**
* ProyectoMidlet
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class ProyectoMidlet extends MIDlet implements CommandListener
{
     //ATRIBUTOS
     private Display display;
     private List listaMenu;
     private Command comandoSalir;
     private Command comandoAceptar;
     private Form formaPreguntas;

     //Cosntructor
     public ProyectoMidlet()
     {
          display = Display.getDisplay( this );
          comandoSalir = new Command("Salir",Command.OK,1);
          comandoAceptar = new Command("Aceptar",Command.OK,1);
          formaPreguntas = new Form("Preguntas");
     }//ProyectoMidlet

     //MÉTODOS
     public void startApp()
     {
          listaMenu = new List("Selecciona una opción", Choice.IMPLICIT);
          listaMenu.append("Culturas", null);
          listaMenu.append("Presidentes", null);
          listaMenu.append("Historia", null);
          listaMenu.addCommand(comandoSalir);
          listaMenu.addCommand(comandoAceptar);
          listaMenu.setCommandListener(this);
         display.setCurrent(listaMenu);
     }//startApp

     public void pauseApp()
    {
    }//pauseApp

     public void destroyApp(boolean unconditional)
    {
    }//destroyApp

     public void commandAction (Command c, Displayable d)
     {
          if (c == comandoSalir)
          {
                try
               {
                     destroyApp(true);
                     notifyDestroyed();
               }//try

              catch(Exception e)
              {
                   System.out.println(e.toString());
              }//catch
         }//if
         else if (c == comandoAceptar)
               {
                     Questionnaire questionnaire = new Questionnaire(
                      listaMenu.getString(listaMenu.getSelectedIndex()),
                      "/Cuestionario"+(listaMenu.getSelectedIndex()+1)+".txt",this);
                      questionnaire.apply();
                      String s="preguntas="+questionnaire.getNumberOfQuestions()+",           correctas="+questionnaire.getNumberOfCorrectAnswers();
                      Ticker ticker= new Ticker(s);
                       listaMenu.setTicker(ticker);
                }//if
     }//CommandAction

     public Display getDisplay()
     {
          return display;
     }//getDisplay

     public Form getFormaPreguntas()
     {
          return formaPreguntas;
     }//getFormaPreguntas

     public List getListaMenu()
    {
          return listaMenu;
     }//getListaMenu
}

*****************Questionnaire**********************
/**
* Questionnaire
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

import javax.microedition.lcdui.*;

// Se definen tanto los atributos como los métodos que conforman a la clase Questionnaire
public class Questionnaire
{
     // ATRIBUTOS
     private String name;
     private String fileLocation;
     private int numberOfQuestions;
     private int numberOfCorrectAnswers;
     private ProyectoMidlet theMidlet;
     private Cuestionario cuestionario;
     private ChoiceGroup grupo;
     private Command comandoSiguiente;

     // MÉTODOS

     // Constuctor de la clase
     // Se le pasa el nombre y la localización del archivo .txt donde estan las preguntas
     // y las posibles respuestas
     public Questionnaire(String aName, String aFileLocation, ProyectoMidlet aMidlet)
     {
          name=aName;
          fileLocation = aFileLocation;
          theMidlet = aMidlet;
          numberOfCorrectAnswers = 0;
          numberOfQuestions = 0;
          comandoSiguiente = new Command("Siguiente", Command.OK, 1);
     }//Questionnaire

     // Nombre del cuestionario
     public String getName()
     {
          return name;
     }//getName

     //Presenta el cuestionario en el celular, para que el usuario lo responda
     public void apply()
     {
          Lectura lectura = new Lectura(fileLocation);
          String cadena = lectura.getContent();
          Analiza analiza= new Analiza(cadena);
          cuestionario = analiza.getCuestionario();
          grupo = new ChoiceGroup(cuestionario.getPregunta(numberOfQuestions).getSentenciaPregunta(),Choice.EXCLUSIVE);
          for (int i=0; i<cuestionario.getPregunta(numberOfQuestions).getNumOpciones();i++)
               grupo.append(cuestionario.getPregunta(numberOfQuestions).getOpcionPregunta(i), null);
          theMidlet.getFormaPreguntas().deleteAll();
          theMidlet.getFormaPreguntas().append(grupo);
          theMidlet.getFormaPreguntas().addCommand(comandoSiguiente);
          theMidlet.getFormaPreguntas().setCommandListener(new CommandListener() {
               public void commandAction(Command c, Displayable d) {
                    if (c==comandoSiguiente)
                         if(numberOfQuestions < cuestionario.getNumeroPreguntas())
                         {
                               if (cuestionario.getPregunta(numberOfQuestions).getCorrectoIncorrecto(grupo.getSelectedIndex()))
                                   numberOfCorrectAnswers = numberOfCorrectAnswers + 1;
                              numberOfQuestions = numberOfQuestions + 1;
                              System.out.println(numberOfQuestions);
                              System.out.println(numberOfCorrectAnswers);
                              apply();
                         }
                         else
                               theMidlet.getDisplay().setCurrent(theMidlet.getListaMenu());
          }
     });
     theMidlet.getDisplay().setCurrent(theMidlet.getFormaPreguntas());
}//apply

     // Proporciona el número de preguntas que tiene el cuestionario
     public int getNumberOfQuestions()
     {
          System.out.println(numberOfQuestions);
          return numberOfQuestions;
     }//getNumberOfQuestions

     // Proporciona el número de preguntas correctamente contestadas por el usuario
     public int getNumberOfCorrectAnswers()
     {
          System.out.println(numberOfCorrectAnswers);
          return numberOfCorrectAnswers;
      }//getNumberOfCorrectAnswers
}//Questionnaire

********************Lectura************************
/**
* Lectura del archivo plano txt
* Código expuesto en clase y retomado para mi proyecto
* @author Gerardo Ayala San Martin
*/

// Paquete para la lectura del archivo
import java.io.InputStream;

public class Lectura
{
     // ATRIBUTOS
     InputStream inputStream;

     // Constructor
     public Lectura(String textFileRoute)
     {
          inputStream=this.getClass().getResourceAsStream(textFileRoute);
     }

     // MÉTODOS
     public String getContent()
     {
          //Variables
          StringBuffer stringBuffer = null;
          int aByte;
          try
          {
               stringBuffer = new StringBuffer();
               //Lectura del archivo
               aByte=0;
               while ((aByte = inputStream.read())!= -1)
               {
                    stringBuffer.append((char) aByte);
               }//while
          }//try
          catch (Exception exception)
          {
               System.out.println("No se puede leer el archivo: "+ exception);
          }//catch
          return stringBuffer.toString();
     }//getContent
}//Lectura

********************Analiza************************
/*
* Analiza
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

//En la Clase Analiza se lleva a cabo el analisis de una cadena, llamada cadenota,
//la cual esta conformada por toda la estructura del archivo .txt

public class Analiza
{
     // ATRIBUTOS
     String cadena;
     Cuestionario cuestionario;

     //Constructor
     public Analiza(String aCadena)
     {
          cadena = aCadena;
          cadena = reemplazaCadena(cadena,"\r\n","");
          cuestionario = new Cuestionario(nombreCuestionario(),cuentaEtiqueta(cadena,"<question>"));
          cadena = quitaEtiqueta(cadena,"<questionnaire>","</questionnaire>");
          cadena = reemplazaCadena(cadena,cuestionario.getNombreCuestionario(),"");
          obtienePreguntas(cadena);
     }

     //MÉTODOS

     //Método que retorna la posición en que se encuentra una determinada cadena
     //dentro de la cadenota
     public int regresaPosicionCadena(String cadenota, String subCadena)
     {
          if (subCadena.length()<cadenota.length())
         {
               for (int i=0 ; i<=(cadenota.length()- subCadena.length()) ; i++)
               {
                    if (subCadena.equals(cadenota.substring(i, i+subCadena.length())))
                         return i;
               }//for
         }//if
         return -1;
     }//regresaPosicionCadena

     //Método que elimina los caracteres "\r\n" de la cadenota
     public String reemplazaCadena(String cadenota, String subCadena, String reemplazo)
     {
          int posicion = regresaPosicionCadena(cadenota,subCadena);
          while(posicion!=-1)
          {
               cadenota = cadenota.substring(0,posicion)+reemplazo+cadenota.substring(posicion+subCadena.length());
               posicion = regresaPosicionCadena(cadenota,subCadena);
          }//while
          return cadenota;
     }//reemplazaCadena

     //Método que retorna el número de etiquetas que hay en la cadenota
     public int cuentaEtiqueta(String cadenota, String etiqueta)
     {
          int conteo = 0;
          int posicion = regresaPosicionCadena(cadenota,etiqueta);
          while (posicion!=-1)
          {
               conteo = conteo + 1;
               cadenota = cadenota.substring(posicion + etiqueta.length());
               posicion = regresaPosicionCadena(cadenota,etiqueta);
          }//while
          return conteo;
     }//cuentaEtiqueta

     //Método que quita la etiqueta tanto inicial como final de la cadenota
     public String quitaEtiqueta(String cadenota, String etiquetaInicial, String etiquetaFinal)
     {
          cadenota = reemplazaCadena(cadenota,etiquetaInicial,"");
          cadenota = reemplazaCadena(cadenota,etiquetaFinal,"");
          return cadenota;
     }//quitaEtiqueta

     //Método que retorna el contenido que hay entre dos etiquetas
     public String regresaContenidoEntreCadenas(String cadenota, String subCadenaInicial, String subCadenaFinal)
     {
          return cadenota.substring(regresaPosicionCadena(cadenota,subCadenaInicial)+subCadenaInicial.length(),regresaPosicionCadena(cadenota,subCadenaFinal));
     }//regresaContenidoEntreCadenas

     //Método que retorna la cadena
     public String getCadena()
     {
          return this.cadena;
     }//getCadena

     //Método que retorna el contenido que exite entre las etiquetas "<questionnaire>","<question>",
     //es decir, el nombre del cuestionario
     public String nombreCuestionario()
     {
          return regresaContenidoEntreCadenas(this.cadena, "<questionnaire>","<question>" );
     }//nombreCuestionario

     public void obtienePreguntas(String cadenota)
     {
          for (int i=0 ; i<cuestionario.getNumeroPreguntas() ; i++)
          {
               String stringPregunta = regresaContenidoEntreCadenas(cadenota,"<question>","</question>");
               String sentenciaPregunta = stringPregunta.substring(0,regresaPosicionCadena(stringPregunta, "<answer>"));
               String stringOpcionesPregunta = stringPregunta.substring(regresaPosicionCadena(stringPregunta, "<answer>"));
               Pregunta pregunta = new Pregunta(sentenciaPregunta,cuentaEtiqueta(stringOpcionesPregunta,"<answer>"));
               for(int j=0; j<pregunta.getNumOpciones(); j++)
               {
                    pregunta.setOpcionPregunta(regresaContenidoEntreCadenas(stringOpcionesPregunta,"<answer>","<isCorrect>"),j);
                     if (regresaContenidoEntreCadenas(stringOpcionesPregunta,"<isCorrect>","</isCorrect>").equals("true"))
pregunta.setCorrectoIncorrecto(true,j);
                    else
                             pregunta.setCorrectoIncorrecto(false,j);
                    stringOpcionesPregunta = stringOpcionesPregunta.substring(regresaPosicionCadena(stringOpcionesPregunta,"</answer>")+9);
               }//for j
               cadenota = cadenota.substring(regresaPosicionCadena(cadenota,"</question>")+11);
               cuestionario.setPregunta(pregunta,i);
          }//for i
     }//obtienePreguntas

     //Método que regresa el cuestionario
     public Cuestionario getCuestionario()
     {
          return cuestionario;
     }//getCuestionario
}

****************Cuestionario **********************
/**
* Cuestionario
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/
public class Cuestionario
{
     //ATRIBUTOS
     private String nombre;
     private Pregunta preguntas[];

     //Constructores
     public Cuestionario()
     {
          nombre = "";
          preguntas = new Pregunta[5];
     }//Cuestionario()

     public Cuestionario(String aNombre)
     {
          nombre = aNombre;
          preguntas = new Pregunta[5];
     }//Cuestionario

     public Cuestionario(String aNombre, int numeroPreguntas)
     {
          nombre = aNombre;
          preguntas = new Pregunta[numeroPreguntas];
     }//Cuestionario(String aNombre, int numeroPreguntas)

     public void setNombreCuestionario(String aNombre)
     {
          nombre = aNombre;
     }//setNombreCuestionario

     public String getNombreCuestionario()
     {
          return nombre;
     }//getNombreCuestionario

     public Pregunta getPregunta(int indice)
     {
          return preguntas[indice];
     }//getPregunta

     public void setPregunta(Pregunta aPregunta, int indice)
     {
          preguntas[indice] = aPregunta;
     }//setPregunta

     public int getNumeroPreguntas()
     {
          return preguntas.length;
     }//getNumeroPreguntas
}

*********************Pregunta*********************
/**
* Estructura de la pregunta
* @author Leticia Estrada González
* 210174
* Marzo 2010
*/

public class Pregunta
{
     //ATRIBUTOS
     private String sentenciaPregunta;
     private String opcionesPregunta[];
     private boolean correctoIncorrecto[];

     // Constuctor de la clase
     public Pregunta()
     {
          this.sentenciaPregunta = "";
          this.opcionesPregunta = new String[5];
          this.correctoIncorrecto = new boolean[4];
     }//Pregunta()

     //sobrecarga del constructor, se le pasa como parámetro solamente la pregunta
     public Pregunta(String sentenciaPregunta)
     {
          this.sentenciaPregunta = sentenciaPregunta;
          this.opcionesPregunta = new String[5];
          this.correctoIncorrecto = new boolean[4];
     }//Pregunta

     //sobrecarga del constructor, se le pasa como parámetros la pregunta y el número de opciones
     public Pregunta(String sentenciaPregunta, int numOpciones)
     {
          this.sentenciaPregunta = sentenciaPregunta;
          this.opcionesPregunta = new String[numOpciones];
          this.correctoIncorrecto = new boolean[numOpciones];
     }//Pregunta

     //MÉTODOS
     // Método que regresa el número de opciones de la pregunta
     public int getNumOpciones()
     {
          return this.opcionesPregunta.length;
     }//getNumOpciones

     // Método que regresa la opción con su respectivo indice
     public String getOpcionPregunta(int indice)
     {
          return this.opcionesPregunta[indice];
     }//getOpcionesPregunta

     // Método que establece la opcion de la pregunta y su indice
     public void setOpcionPregunta(String opcionPregunta,int indice)
     {
     this.opcionesPregunta[indice]=opcionPregunta;
     }//setOpcionesPregunta

     // Método que regresa la pregunta
     public String getSentenciaPregunta()
     {
          return this.sentenciaPregunta;
     }//getSentenciaPregunta

     public void setSentenciaPregunta(String sentenciaPregunta)
     {
          this.sentenciaPregunta = sentenciaPregunta ;
     }//setSentenciasPregunta

     public boolean getCorrectoIncorrecto(int indice)
     {
          return correctoIncorrecto[indice];
     }//getCorrectoIncorrecto

     public void setCorrectoIncorrecto(boolean correctoIncorrecto, int indice)
     {
          this.correctoIncorrecto[indice]=correctoIncorrecto;
     }//setCorrectoIncorrecto
}

Cuestionario3

<questionnaire>

Historia de Mexico
<question>
Año en que inicio la independencia de Mexico
<answer>
16 de septiembre de 1910
<isCorrect>
false
</isCorrect>
</answer>
<answer>
20 de noviembre de 1810
<isCorrect>
false
</isCorrect>
</answer>
<answer>
16 de septiembre de 1810
<isCorrect>
true
</isCorrect>
</answer>
<answer>
20 de noviembre de 1910
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Año en que inicio la revolucion mexicana
<answer>
16 de septiembre de 1910
<isCorrect>
false
</isCorrect>
</answer>
<answer>
20 de noviembre de 1810
<isCorrect>
false
</isCorrect>
</answer>
<answer>
16 de septiembre de 1810
<isCorrect>
false
</isCorrect>
</answer>
<answer>
20 de noviembre de 1910
<isCorrect>
true
</isCorrect>
</answer>
</question>
<question>
Año en que ocurrio la batalla del 5 de mayo
<answer>
1910
<isCorrect>
false
</isCorrect>
</answer>
<answer>
1920
<isCorrect>
false
</isCorrect>
</answer>
<answer>
1862
<isCorrect>
true
</isCorrect>
</answer>
<answer>
1847
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Nombre del niño heroe que se lanzo al vacio envuelto en la bandera
<answer>
Juan de la Barrera
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Juan Escutia
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Agustin Melgar
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Vicente Suarez
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Fecha en la que Lazaro Cardenas expropio el petroleo
<answer>
18 de marzo de 1938
<isCorrect>
true
</isCorrect>
</answer>
<answer>
18 de marzo de 1838
<isCorrect>
false
</isCorrect>
</answer>
<answer>
21 de marzo de 1806
<isCorrect>
false
</isCorrect>
</answer>
<answer>
21 de marzo de 1938
<isCorrect>
false
</isCorrect>
</answer>
</question>
</questionnaire>

Cuestionario2

<questionnaire>
Presidente de México
<question>
Primer emperador de México
<answer>
Vicente Guerrero
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Antonio López de Santa Ana
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Guadalupe Victoria
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Agustin de Iturbide
<isCorrect>
true
</isCorrect>
</answer>
</question>
<question>
Primer presidente de México
<answer>
vicente Guerrero
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Guadalupe Victoria
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Jose Maria Bocanegra
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Agustin de Iturbide
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Presidente mexicano que ocupo once veces la presidencia
<answer>
Porfirio Diaz
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Valentin Gomez Farias
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Antonio López de Santa Ana
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Nicolás Bravo
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Presidente que creo las leyes de reforma
<answer>
Porfirio Diaz
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Ignacio Comonfort
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Francisco I. Madero
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Benito Juarez
<isCorrect>
true
</isCorrect>
</answer>
</question>
<question>
Presidente que vendio Telmex, privatizo la banca y realizó el TLC
<answer>
Carlos Salinas de Gortari
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Miguel de la Madrid Hurtado
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Ernesto Zedillo Ponce de Leon
<isCorrect>
false
</isCorrect>
</answer>
<answer>
José López Portillo y Pacheco
<isCorrect>
false
</isCorrect>
</answer>
</question>
</questionnaire>

Cuestionario1

<questionnaire>
Culturas de México
<question>
Cultura que fue conquistada por Hernán Cortés
<answer>
Maya
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Azteca
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Olmeca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Zapoteca
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Cultura que destaco por su sabiduría y entendían el concepto de cero
<answer>
Tolteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Zapoteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Maya
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Teotihuacana
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
Cultura que realizaron las llamadas cabezas colosales, se le considera "la cultura madre" de Mesoamérica
<answer>
Azteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Zapoteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Tolteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Olmeca
<isCorrect>
true
</isCorrect>
</answer>
</question>
<question>
Cultura que levanto columnas enforma de guerreros llamados "Atlantes"
<answer>
Teotihuacana
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Tolteca
<isCorrect>
true
</isCorrect>
</answer>
<answer>
Zapoteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Maya
<isCorrect>
false
</isCorrect>
</answer>
</question>
<question>
La serpiente emplumada es una de las imágenes más importantes de que cultura
<answer>
Azteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Tolteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Zapoteca
<isCorrect>
false
</isCorrect>
</answer>
<answer>
Teotihuacana
<isCorrect>
true
</isCorrect>
</answer>
</question>
</questionnaire>

Desarrollo de Software para Teléfonos Celulares

Saludos a todos!!!