LENGUAJES Y AUTÓMATAS

Autómata en Java

Alberto García Rojas – S163014

Mto. Carlos Eduardo López Valencia
Lenguajes y Autómatas I
Ingeniería en Sistemas Computacionales
Ext. Jacona

INSTITUTO TECNOLÓGICO SUPERIOR PURHEPECHA

14/02/2019
Lenguajes y Autómatas - Alberto García Rojas

CONTENIDO
INTRODUCCIÓN .............................................................................................................................. 2
AUTÓMATA HA PROGRAMAR..................................................................................................... 2
ANÁLISIS ........................................................................................................................................... 3
RECURSIVIDAD........................................................................................................................... 3
DIAGRAMA DE FLUJO ............................................................................................................... 3
PROGRAMACIÓN EN JAVA .......................................................................................................... 4
Primer Método “Status 1”. ........................................................................................................... 4
Segundo Método “Status 2” ........................................................................................................ 6
Tercer Método “Status 3”. ........................................................................................................... 6

1
Lenguajes y Autómatas - Alberto García Rojas

INTRODUCCIÓN
En la presente actividad, vamos a desarrollar un autómata programado en lenguaje
java. Los recursos que utilizaremos son: Frames para la interfaz gráfica de usuario,
diagrama de flujo para el análisis del autómata, y el autómata que nos han
proporcionado.

AUTÓMATA HA PROGRAMAR.
El autómata que vamos a programar es el siguiente:

∑ = {a, b, c, d}

El diagrama es el siguiente.

Con ayuda del diagrama podemos analizar una cadena entrante y comprobar si es
aceptada o no.

2
Lenguajes y Autómatas - Alberto García Rojas

ANÁLISIS
El autómata tiene 6 estados, en 3 de ellos (q2, q4 y q5) hay ciclos, por esto, una
estructura hecha por medio de condicionales no funciona, porque en dichos ciclos
podemos repetir el carácter infinidad de veces. Debido a esto, pensé que cada
estado seta un método, al hacerlo así, podemos utilizar la recursividad y esto nos
permitirá regresar a un estado tantas veces como necesitemos.

RECURSIVIDAD
La recursividad es una herramienta de programación que ayuda a crear ciclos, como
un for o un while, pero en un método recursivo dicho método se llama a sí mismo, y
esto es lo que crea el ciclo.

DIAGRAMA DE FLUJO
El siguiente diagrama representa el camino que sigue cada carácter de la cadena,
para comprobar si ésta es aceptada o no.

3
Lenguajes y Autómatas - Alberto García Rojas

PROGRAMACIÓN EN JAVA
Para iniciar el programa en java, vamos a enlistar lo que necesitaremos:

1. Seis métodos que harán la función de los estados.

2. Una variable booleana que llamaremos “isAcepted” que tomara el valor
verdadero o falso, dependiendo de si la cadena fue aceptada o no.
3. Un frame para la interfaz gráfica el cual contendrá
- Text field
- Etiquetas
- Un botón

Primer Método “Status 1”.

public void status1(String s, int index, int size) {

if (s.charAt(index) == 'a') {
status2(s, index + 1, size - 1);
}
if (s.charAt(index) == 'b') {
status3(s, index + 1, size - 1);
}
}

La función de este método es determinar si el primer carácter ingresado es ‘a’ o ‘b’

de lo contrario la cadena será invalida. En los parámetros recibe la cadena
completa, el índice que se está analizando, es decir, el número de carácter que se
está procesando y la medida de la cadena. Explicare cada uno de los parámetros
en este momento, ya que todos los demás métodos recibirán los mismos
parámetros y cumplirán la misma función que en este.

La cadena “s” es el texto introducido por el usuario, el cual lo tomamos del “text field”
como se muestra en la figura 1.

4
Lenguajes y Autómatas - Alberto García Rojas

Figura 1.

Este primer método se invoca cuando presionamos el botón “comprobar” el cual

pasa como parámetro:

1. La cadena en sí.
2. El índice con el cual queremos iniciar el análisis, éste siempre será 0.
3. El tamaño de la cadena, que en este ejemplo es 3

La cadena va a pasar completa a los demás métodos, pero según avancemos lo

que cambiara es el índice y el tamaño. Al índice le vamos sumando uno en cada
iteración para ir recorriendo cada carácter. A la medida de la cadena le restamos
uno; esto es para comprobar que analicemos toda la cadena, y en caso de que esta
variable llegue a 0 y no haya terminado el recorrido, o llegado al estado de
aceptación, nos ayudará determinar que la cadena no es aceptada.

Dicho lo anterior, vamos a explicar que hace el método en sí. Como podemos
observar en el autómata, el estado inicial solo acepta una ‘a’ o ‘b’. Mediante las
estructuras de control “if” comprobamos que la entrada sea ‘a’ o ‘b’, de lo contrario
la cadena no será válida porque el programa no continuará a ningún otro estado y

5
Lenguajes y Autómatas - Alberto García Rojas

la variable booleana esta definida en “false”. Dicha variable es la que cambia según
la cadena sea aceptada o no.

Podemos observar que este método puede ejecutar otros 2 métodos. “Status 2” y
“Status 3” dependiendo del valor de entrada.

Segundo Método “Status 2”

Al llegar a este método se comprobará si el siguiente carácter es ‘c’ o ‘d’.

public void status2(String s, int index, int size) {

try {
if (s.charAt(index) == 'c') {
status2(s, index + 1, size - 1);
} else {
isAcepted = false;
}

if (s.charAt(index) == 'd') {
status1(s, index + 1, size - 1);
}
} catch (Exception e) {
isAcepted = false;
}
}

Como Podemos observar, al comprobar que se a introducido una ‘c’ el método se

vuelve a llamar a sí mismo, es aquí donde se aplica la recursividad, y, mientras
sigua leyendo una ‘c’ el programa volverá a ejecutar el método “status2” pero al
recibir una ‘d’ volveremos a “status1”, en caso de recibir cualquier otra cosa, o se
haya recorrido toda la cadena, el try-catch nos ayudara a determinar si la cadena
es invalida, ya que de tener alguna excepción, la parte del catch hará falsa a la
variable booleana.

Tercer Método “Status 3”.

Este método realiza lo mismo que el anterior, la diferencia es que nos conduce al
estado 4 o 5.

6
Lenguajes y Autómatas - Alberto García Rojas

public void status3(String s, int index, int size) {

try {
if (s.charAt(index) == 'c') {
status4(s, index + 1, size - 1);
} else {
isAcepted = false;
}

if (s.charAt(index) == 'd') {
status5(s, index + 1, size - 1);
}
} catch (Exception e) {
isAcepted = false;
}
}

Cuarto Método “Status 4”

Analizando el método concluimos que funciona igual que los dos anteriores, solo
que esta ves una de las opciones nos lleva a un estado final.

public void status4(String s, int index, int size) {

try {
if (s.charAt(index) == 'a') {
status4(s, index + 1, size - 1);
} else {
isAcepted = false;
}

if (s.charAt(index) == 'c') {
status6_final(size - 1);
}
} catch (Exception e) {
isAcepted = false;
}
}

7
Lenguajes y Autómatas - Alberto García Rojas

Quinto Método “Status 5”

Este es el otro método que nos puede conducir al estado de aceptación,

public void status4(String s, int index, int size) {

try {
if (s.charAt(index) == 'a') {
status4(s, index + 1, size - 1);
} else {
isAcepted = false;
}

if (s.charAt(index) == 'c') {
status6_final(size - 1);
}
} catch (Exception e) {
isAcepted = false;
}
}

8
Lenguajes y Autómatas - Alberto García Rojas