sábado, 23 de julio de 2016
jueves, 21 de julio de 2016
SENTENCIA DE FLUJOS: CONDICIONALES - CASOS Y BUCLES
Control de Flujo
Hasta ahora un programa no era más que una secuencia de instrucciones que son ejecutadas en el orden en que son formuladas. Además, si quisieramos que un conjunto de ellas se repitiera varias veces, no tenemos más remedio que escribirlas varias veces. El orden de ejecución de las sentencias es lo que se conoce por el flujo del programa, y se puede variar a voluntad utilizando las sentencias de control de flujo, con las que es muy fácil alterarlo para adecuarlo a nuestras necesidades. Esto es lo que hace potentes a los lenguajes de programación. Básicamente, existen tres tipos de sentencias, secuencial, condicional e iterativa, y con ellas se puede escribir cualquier programa.
Sentencias Condicionales
Exiten dos formas de alterar el flujo dependiendo de una condición. La idea básica es la de encontrarnos ante una bifurcación de un camino, en la que seguiremos por uno u otro camino dependiendo de la respuesta a una pregunta que se halla escrita en la bifurcación. Una variante de esto es que en lugar de dos posibilidades, se nos presenten más caminos por los que poder seguir.
Sentencia if-else
La forma más elemental de control de flujo condicional es la sentencia if-else, cuya sintaxis es la siguiente:
if (expresión_condicional)
sentencia1
else
sentencia2
Una sentencia if evaluará primero su condición, y si se evalúa como true ejecutará la sentencia o bloque de sentencias que se encuentre justo después de la condición. Si la condición se evalúa como false y existe una cláusula else, entonces se ejecutará la sentencia o bloque de sentencias que siguen al else. Esta parte es opcional. La única restricción que se impone a la expresión condicional es que sea una expresión válida de tipo booleano que se evalúe como true o como false.
Un ejemplo de código con un if-else es el siguiente, en el que se elige el mayor de dos enteros:
int a=3, b=5, m;
if (a<b)
m=a;
m=b;
else
Un ejemplo de condicional sin parte else es el siguiente, donde se imprime si un número es par o impar:
int a=3;
String mensaje="El número " + a + " es ";
if (a%2 != 0)
mensaje+="im";
System.out.println(mensaje);
mensaje+="par.";
produciendo el resultado
El número 3 es impar.
El número 4 es par.
dependiendo de si a es inicializada a 3 o a 4.
Es posible construir una serie de comprobaciones uniendo un if a la cláusula else de un if anterior. Por ejemplo, el siguiente trozo de código muestra una calificación dada una nota numérica:
float nota=6.7F;
String calificacion;
if(nota>=9.0)
calificacion="Sobresaliente";
else if(nota>=7.0)
calificacion="Notable";
else
else if(nota>=5.0)
calificacion="Aprobado";
System.out.println("La calificación obtenida es: " + calificacion);
calificacion="Suspenso";
En este tipo de secuencias de sentencias if-else anidadas las cláusulas else siempre se emparejan con el if más cercano sin else. Para variar este comportamiento se deben utilizar llaves para crear bloques de sentencias.
Sentencia switch
Una sentencia switch se emplea para efectuar selecciones múltipes que bifurcarán a diferentes segmentos de código dependiendo del valor de una variable o una expresión entera.
La forma general de una sentencia switch es la siguiente:
switch (expresion) {
case valor1:
bloque_código_1;
break;
case valor2:
...
bloque_código_2;
break;
case valorN:
bloque_código_default;
bloque_código_N;
break;
default:
break;
}
Las expresiones empleadas en una sentencia switch deben ser de tipo entero o de cualquier otro tipo que pueda ser convertido implícitamente en tipo int sin pérdida de información: byte, short y char. Para los tipos long, float y double se necesita una conversión explícita. Los valores case deben ser expresiones que puedan ser evaluadas como constantes enteras o convertidas implícitamente a un valor de tipoint.
Una sentencia switch evalúa una expresión entera cuyo valor se usa para encontrar una etiqueta case adecuada entre las presentes en el bloque siguiente. Si se encuentra una estiqueta case adecuada, se ejecutan las sentencias comenzando por la primera sentencia que la sigue hasta que encontremos una cláusula break o la llave } del bloque switch. Si no, se ejecutan las sentencias que se encuentran tras la etiqueta default si la hubiere. Si no hay etiqueta default se salta toda la sentencia switch.
Todas las etiquetas case deben ser expresiones constantes, es decir, deben contener sólo literales o campos static final inicializados con expresiones constantes. Los valores case deben ser únicos y haber como máximo una etiqueta default.
El siguiente código asigna un color a un número:
int codigoColor=4;
String color;
switch (codigoColor){
case 0:
color="negro";
color="rojo";
break;
case 1:
break;
break;
case 2:
color="amarillo";
case 3:
color="indefinido";
color="azul";
break;
default:
}
System.out.println("El color "+codigoColor+" corresponde al "+color);
En algún caso puede convenir agrupar más de un caso bajo el mismo comportamiento; y otras veces no se especificará una sentencia break en cada caso para que la ejecución traspase más de un caso en cascada. Esto se puede ver en el siguiente ejemplo que calcula la potencia i-ésima de 2:
int i=3;
long base=2;
long número=base;
if (0<=i && i<=4){
switch (i){
número*=base;
case 4:
case 3:
case 2:
número*=base;
número*=base;
número=base;
break;
case 1:
break;
case 0:
System.out.println("la potencia "+i+"-esima de "+base+" es "+número);
número=0;
break;
}
} else
System.out.println("ERROR: exponente negativo o demasiado grande.");
Sentencias Repetitivas
Las sentencias repetitivas o de bucle permiten la ejecución repetida de bloques de sentencias. Existen tres tipos de sentencias: bucles while, do-while y for. Los bucles de tipo while y for comprueban si deben continuar repitiendo la sentencia o bloque de sentencias que forman el cuerpo del bucle antes de que el cuerpo del bucle se ejecute, mientras que el bucle do-while lo hace después de haberlo ejecutado.
Otra consideración a hacer es que debemos utilizar un bucle for cuando sepamos el número de veces que se ha de repetir la ejecución del cuerpo del bucle, mientras el bucle while será más adecuado cuando el control de la repetición recae en una condición de otro tipo.
Bucles while y do-while
La forma general de un bucle while es la siguiente:
while (expresiónBooleana)
sentencia;
En un bucle while primero se evalúa la expresión booleana. Si esta es true, entonces el cuerpo del bucle será ejecutado. En otro caso, la ejecución pasará a la sentencia inmediatamente siguiente al buclewhile. El cuerpo del bucle puede ejecutarse 0 o más veces, ya que la primera vez que se evalúe la expresión booleana puede ser false. Si la expresión booleana nunca se evalúa a false nos encontraremos con un bucle infinito, ya que nunca acabará. Este tipo de situación conviene ser evitada, ya que produce programas que nunca acaban.
El siguiente trozo de código muestra los números del 1 al 10:
int n=1;
while (n<=10){
System.out.println(n);
n++;
}
Si la expresión booleana nunca se evalúa a false nos encontraremos con un bucle infinito, ya que nunca acabará. Este tipo de situación conviene ser evitada, ya que produce programas que nunca acaban. Esto se puede ver si en el ejemplo anterior comentamos la sentencia de incrementa n:
int n=1;
while (n<=10){
System.out.println(n);
//n++;
}
Como n nunca se incrementa, nunca llegará a valer 10, y por lo tanto la expresion booleana siempre será evaluada como true.
A veces puede venir bien que el cuerpo del bucle se ejecute al menos una vez, razón por la que Java tiene el bucle do-while, cuya forma general es la siguiente:
do
sentencia;
while (expresiónBooleana);
Bucles for
La forma general de un bucle for es la siguiente:
for (exprInicialización; exprBooleana; exprIncremento)
sentencia;
que es equivalente a
exprInicialización;
while (exprBooleana){
sentencia;
}
exprIncremento;
Un ejemplo de utilización de un bucle for es el siguiente, donde se calcula el factorial de un número positivo:
int n=4; // número para calcular su factorial
int i; // indice del for
if (n>1) {
long factorial=1; // 1! y 0! son igual a 1
for(i=n;i>1;i--)
System.out.println(n+"!="+factorial);
factorial*=i;
}
Las sentencias de inicialización e iteración de un bucle for pueden ser una lista de expresiones separadas por comas, que se evalúan, de izquierda a derecha. Todas las expresiones del bucle for son opcionales. Si exprInicialización o exprIncremento se omiten, se suprime su participación en el bucle. Si la exprBooleana se omite, se supone que es true, por lo que el siguiente puede ser un la representación de un bucle infinito:
for (;;)
sentencia;
Los bucles están relacionados de una manera natural con el tratamiento de los elementos de un array. Así, el bucle básico que recorre todos los elementos de un array puede ser el siguiente:
int [] a={10,11,12,13,14,15,16,17,18,19};
for(int i=0;i<a.length;i++)
System.out.println("a["+i+"]="+a[i]);
Sentencias de Alteración del Flujo
Java soporta tres tipos de sentencias de alteración del flujo: break, continue y return. break se usa para salir de sentencias switch, bucles y bloques de sentencias. continue se usa para bifurcar al final de un bucle justo tras la última sentencia del cuerpo del bucle. return se usa para salir de un método o de un constructor.
Se utilizará break para salir de cualquier bloque, no sólo de un switch, aunque se suele utilizar para salir de un bucle. Un break termina el switch, for, while o do-while más interno.
Una sentencia continue salta al final del cuerpo de un bucle y evalúa la expresión booleana que controla dicho bucle.
La forma general de la sentencia return es la siguiente:
return expresión;
Se usa para devolver el control al lugar desde el que se efetuó la llamada al método o constructor en cuestión. El tipo de la expresión incluida en el return debe ser compatible con el tipo declarado del método. Como los métodos no tienen tipo devuelto, son void, el return no debe llevar expresión asociada.
Un Ejemplo
A continuación se presenta un ejemplo en el que se manejan sentencias condicionales e iterativas. En el ejemplo se crea una clase de matrices de dos dimensiones y se aportan un constructor para crear e inicializar la matriz y varios métodos para manejar dicha matriz.
/**
M2 es una clase de una matriz de enteros
positivos de dos dimensiones
*/
private int[][] a; // tenemos una matriz de dos dimensiones
class M2{
/** constructor no-arg */
int fila0[]={1,4,5,3,3};
M2(){
a=new int[3][];
int fila2[]={9,7,2,5,4};
int fila1[]={1,1,4,8};
a[0]=fila0;
/** método para leer un elemento de la matriz */
a[1]=fila1;
a[2]=fila2;
}
/* si las coordenadas son correctas */
public int leerM2(int i, int j){
return a[i][j]; // devolver el elemento solicitado
if ( (i>=0 && i<a.length) && (j>=0 && j<a[i].length))
else // si no son correctas
/** método para conseguir una versión imprimible del objeto M2 */
return -1; // ERROR en las coordenadas
}
public String toString(){
String mensaje="";
mensaje+="\n";
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length;j++)
mensaje+=leerM2(i,j)+" "; // mensaje+=a[i][j]+" ";
int mayor=a[0][0]; // se quedara con el mayor
}
return mensaje;
}
/** método para encontrar el mayor elemento de un objeto M2 */
public int mayor(){
x=leerM2(i,j); // almacenamos en x el i,j-esimo elemento
int x; // almacen temporal
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length;j++){
public static void main(String [] args){
if (mayor<x) mayor=x; // x es el nuevo mayor
}
}
return mayor;
}
}
/** clase de prueba para M2 */
class prueba{
}
M2 mm = new M2();
System.out.println(mm);
System.out.println("El mayor número es "+mm.mayor());
}
La ejecución de este programa genera la siguiente salida:
1 4 5 3 3
1 1 4 8
9 7 2 5 4
El mayor número es 9
Fuente de Información: http://www.infor.uva.es/~jvegas/cursos/prog/tema4.html
martes, 19 de julio de 2016
FUNCIONES PREDEFINIDAS
Funciones de cadenas II
En esta
pagina seguiremos viendo las funciones predefinidas para cadenas de texto, y en
concreto aquellas que modifican el texto, dando como resultado otra cadena.
Cambiar Mayúsculas y minúsculas:
strtoupper($texto);
Devuelve
la cadena de texto pasada en el argumento $texto con
todas sus letras en mayúsculas.
strtolower($texto);
Devuelve
la cadena de texto pasada en el argumento $texto con
todas sus letras en minúsculas.
ucwords($texto);
Devuelve
la cadena de texto pasada en el argumento $texto con la
primera letra de cada palabra pasada a mayúsculas, siempre que ésta sea un
carácter alfabético.
ucfirst($texto);
Devuelve
la cadena de texto pasada en el argumento $texto con la
primera letra de la cadena en mayúsculas, siempre que ésta sea un carácter
alfabético.
En el
siguiente enlace se muestra una página de ejemplo en la que se usan las
funciones anteriores:
El código
aplicado para crear la página anterior puedes verlo en el siguiente enlace:
Eliminar y remplazar texto.
str_replace($buscar,$remplazar,$texto);
Esta
función es particularmente útil para remplazar una palabra o trozo de texto por
otro, ya que dentro del texto indicado en el tercer argumento $texto, busca los trozos que coinciden con la cadena
indicada en el primer argumento, $buscar, y los
sustituye por la cadena indicada en el segundo argumento $remplazar.
Si en el
segundo argumento $remplazar indicamos una cadena vacia "", lo que hará la función es eliminar del $texto los trozos coincidentes con $buscar.
str_ireplace($buscar,$remplazar,$texto);
Esta
función es igual que la anterior, pero no tiene en cuenta las diferencias entre
letras mayúsculas y minúsculas.
substr($texto,comienzo,longitud);
Devuelve
una parte de la cadena pasada en el primer argumento $texto. El segundo argumento es un número que indica en
que carácter empieza la cadena devuelta, y el tercero indica su longitud.
El tercer
argumento longitud es opcional, y si no se indica,
la cadena devuelta llegará hasta el final de la cadena original.
Los
caracteres de la cadena empiezan a contarse desde el número 0, al igual que en
los arrays, de forma que el primer carácter tiene el número 0, el segundo el 1,
y asi sucesivamente. Esto hay que tenerlo en cuenta al poner el segundo argumento
comienzo.
Si en comienzo ponemos un número mayor que la longitud de la
cadena, la función devolverá "false".
Si en comienzo ponemos un número negativo, los caracteres
empezarán a contarse desde el final de la cadena, de forma que si ponemos por ejemplo
-20, la cadena devuelta serán los 20 últimos caracteres de la cadena original ($texto).
substr_replace($texto,$sustituir,comienzo,longitud);
Devuelve
la cadena pasada en el primer argumento $texto, en la
cual se sustituye un texto por otro. El texto nuevo se indica en el segundo
argumento $sustituir El tercer argumento indica el
comienzo del texto sustituido (viejo) y el cuarto su longitud, ambos argumentos
deben ser números que indican la posición del carácter (tercero) y la cantidad
de caracteres a sustituir.
Al igual
que en la función anterior, si no se indica el argumento longitud, se entiende que ésta es hasta el final de la
cadena; los caracteres se empiezan a contar desde el 0; y si ponemos en comienzo un número negativo, empezaremos a contar desde el
final de la cadena.
str_pad($texto,largo,$relleno,tipo_relleno);
Alarga la
cadena de texto $texto hasta la longitud indicada en largo, para ello se utiliza la cadena indicada en $relleno.
Es decir,
si queremos que una cadena ocupe más espacio del que tiene, alargándola, por,
ejemplo, mediante puntos o guiones, en el argumento $relleno escribiremos ese carácter, con lo cual se alargará
la cadena hasta la longitud indicada.
El cuarto
argumento tipo_relleno es opcional, indica en que lado
de la cadena queremos que aparezcan los caracteres de relleno, podemos poner
tres valores: STR_PAD_RIGHT los caracteres de relleno
aparecerán por la derecha, es la opción por defecto; STR_PAD_LEFT, el relleno aparece a la izquierda; y STR_PAD_BOTH, el relleno aparece repartido a ambos lados de la
cadena.
ltrim($texto,"lista_caracteres");
Modifica
el texto pasado en el primer argumento, $texto: elimina
los primeros caracteres del $texto, si
éstos están en la lista del segundo argumento, "lista_caracteres".
rtrim($texto,"lista_caracteres");
Modifica
el texto pasado en el primer argumento, $texto: elimina
los últimos caracteres del $texto, si
éstos están en la lista del segundo argumento, "lista_caracteres".
trim($texto,"lista_caracteres");
Modifica
el texto pasado en el primer argumento, $texto: elimina
tanto los primeros caracteres como los últimos del $texto, si éstos están en la lista del segundo argumento,
"lista_caracteres".
strtr($texto,"lista_1","lista_2");
Modifica
el texto pasado en $texto, de manera que sustituye los
caracteres de "lista1" por los de "lista2". El primer caracter indicado en "lista1" es sustituido por el primero de "lista2", el segundo de "lista1" es
sustituido por el segundo de "lista2", y así
sucesivamente. Si alguna de las listas es más larga que la otra, los caracteres
sobrantes se ignoran.
En la
siguiente página de ejemplo, mediante varios formularios, el usuario puede
modificar un texto escrito por él mismo, utilizando algunas de las funciones
anteriores.
Puedes
ver el código de esta página en el siguiente enlace, el código tiene
comentarios para ver cómo está construida la página:
Las funciones de cadena trabajan con campos char y varchar por lo que los literales que escribamos se deben encerrar entre comillas simples.
Estas funciones que vamos a explicar a continuación pueden manipular cadenas de letras u otros caracteres por lo que las vamos a dividir en dos grupos:
Funciones que devuelven caracteres
Este tipo de funciones devuelven un carácter o varios caracteres.
| Función | Propósito |
| CHR(n) | Nos devuelve el carácter cuyo valor en binario es n |
| CONCAT(cad1, cad2) | Nos devuelve cad1 concatenada con cad2 |
| UPPER(cad) | Convierte cad a mayúsculas |
| LOWER(cad) | Convierte cad a minúsculas |
| LPAD(cad1,n[,cad2]) | Con esta función añadimos caracteres a cad1 por la izquierda hasta una longitud máxima dada por n |
| INITCAP(cad) | Convierte la primera letra de cad a mayúscula |
| LTRIM(cad [,set]) | Elimina un conjunto de caracteres a la izquierda de cad, siendo set el conjunto de caracteres a eliminar |
| RPAD(cad1, n[,cad2]) | Con esta función añadimos caracteres de la misma forma que con la función LPAD pero esta vez los añadimos a la derecha |
| RTRIM(cad[,set]) | Hace lo mismo que LTRIM pero por la derecha |
| REPLACE(cad,cadena_buscada [,cadena_sustitucion] ) | Sustituye un conjunto de caracteres de 0 o más caracteres, devuelve cad con cada ocurrencia de cadena_buscada sustituida por cadena_sustitucion |
| SUBSTR(cad, m[,n]) | Devuelve la subcadena de cad que abarca desde m hasta el numero de caracteres dados por n. |
| TRANSLATE(cad1,cad2,cad3) | Convierte caracteres de una cadena en caracteres diferentes. Devuelve cad1 con los caracteres encontrados en cad2 y sustituidos por los caracteres de cad3 |
Ponemos algunos ejemplos de utilización de estas funciones:
Sentencia sql que nos devuelve las letras cuyo valor asccii es el 45 y el 23
select CHR(45), CHR(23) FROM TABLA;
Sentencia sql que obtiene el nombre de los alumnos sacando por pantalla la siguiente frase: el nombre del alumno es (nombre que esta almacenado en la tabla)
select CONCAT ('el nombre de alumno es', nombre) from alumno;
Sentencia sql que me devuelve los nombres de los alumnos en mayúsculas
select UPPER(nombre) from alumno;
Sentencia sql que obtiene de un campo nombre, las 3 primeras letras
select SUBSTR(nombre,0,3) from alumno;
Y asi con el resto de funciones…
Funciones que devuelven valores numéricos
Estas funciones nos devuelven números a modo de información.
| Función | Propósito |
| ASCII(cad) | Devuelve el valor ASCII de la primera letra de cad |
| INSTR(cad1, cad2[,comienzo[,m]]) | Función que busca un conjunto de caracteres dentro de una cadena. Nos devuelve la posición de cad2 en cad1 empezando a buscar en comienzo |
| LENGTH(cad) | Devuelve en número de caracteres de cad |
Como con las funciones anteriores dejamos unos ejemplos para que veáis su funcionamiento.
Sentencia sql que nos devuelve el valor ASCII de la letra ('s')
select ASCII('s') from tabla;
Sentencia que nos devuelve la posición de la ocurrencia 'pe' dentro de la cadena 'Los perros están bien' a partir de la posición 2
select INSTR('Los perros están bien','pe',2) from tabla;
Sentencia sql que nos devuelve el numero de caracteres de los nombres de los alumnos
select LENGTH(nombre) from alumnos;
Fuente de Información: http://www.desarrolloweb.com/articulos/funciones-cadena-sql.html
Fuente de Información: http://www.desarrolloweb.com/articulos/funciones-cadena-sql.html
