Mientras Programo

Introducción a PHP

noreply@blogger.com (ADA) — Sun, 14 Apr 2013 15:54:00 +0000

INTRODUCCIÓN

Etiquetas

El código php se escribe dentro de la página web, junto con el html. Se distingue de este último porque el código php va entre unas etiquetas especificas:

<? codigo php ?>

<?php codigo php ?>

<script languaje=”php”> codigo php </script>

Instrucciones

Las instrucciones php terminan en punto y coma ( ; ):

echo “hola mundo”;

En la ultima instrucción no es obligatorio:

echo “esta instrucción es la primera”;

echo “esta es la segunda”;

echo “esta es la ultima”

NOTA: echo sirve para imprimir por pantalla

Comentarios

Comentarios de una linea:

//comentario

#comentario

Comentarios de varias lineas:

/*comentario*/

VARIABLES Y TIPOS DE DATOS

Variables

Se definen poniendo el símbolo dólar ($) delante del nombre de la misma:

$nombreVariable

Tipos

No es necesario declararlas, el tipo depende del contenido de la variable:

Numéricas	Entero	$numero=5;
Numéricas	Real	$numeroReal=5.4;
Alfanuméricas	Cadena	$cadena=”Hola mundo”;
Tablas	Array	$diasSem[0]=”Lunes”; $diasSem[1]=”Martes”; $diasSem[2]=”Miercoles”; ...
Objetos	Instancias de clases

Ej:

NOTA: Dentro de las etiquetas de php se puede incluir código html entre comillas y utilizando echo.

La etiqueta <br/> es el saldo de linea en html.

Cambios de tipo

Las variables se pueden cambiar de tipo siempre que se quiera.

Cambiando el tipo manualmente:

$numero=4; //es un entero

$numero=”hola mundo” //deja de ser entero y pasa a ser cadena

NOTA: Hay que tener cuidado al cambiar de cadena a vector ya que en realidad lo que se hace es modificar los caracteres de la cadena, no transformarla en un vector:

Supongamos que esta es la cadena:

0 1 2 3 4 5 6 7 8 9

Al escribir $cadena[0]=”p” se reemplaza la h por la p ya que es la letra que ocupa la posición 0. La cadena resultante sería "pola mundo".

Usando la función setType:

La sintaxis es: setType(variable, “nuevoTipo”)

El nuevo tipo puede ser:

integer: entero

double: real

string: cadena

array: array

object: objeto

Ej:

La variable inicialmente es una cadena y posteriormente se fuerza su cambio a entero

Haciendo un cast:

Un cast es un cambio de tipo especificado a través de unos parentesis. Igual que se hace en C o en otros lenguajes:

variable2 = (nuevo tipo) variable;

Los cast permitidos son:

(int), (integer) : entero

(real), (double), (float): real

(string): cadena

(array): array

(object): objeto

Ej:

Al hacer el cast la segunda variable guarda el 5 como una cadena “5”

OPERADORES

Aritméticos

Sirven para realizar operaciones aritméticas.

Operador	Operación
+	Suma
-	Resta
*	Producto
/	División
%	Resto de la división
++	Incremento
–	Decremento

Ej:

Suma:

Resultado:

5 + 3 = 8

Resta:

Resultado:

5 - 3 = 2

Producto:

Resultado:

5 * 3 = 15

División entera y resto:

Resultado:

5 / 3 = 1Resto:5 % 3 = 2

División real:

Resultado:

5 / 3 = 1.6666666666667

Incremento:

Resultado: Se incrementa en una unidad el valor de la variable tanto usando el operador como prefijo (delante de la variable) como usándolo como postfijo (detrás de la variable).

Decremento:

Resultado: Decrementa en una unidad.

De comparación

Devuelven verdadero si se cumple la condición y falso si no se cumple.

Operador	Operación
==	Comparación
!=	Desigualdad
>	Mayor que
>=	Mayor o igual
<	Menor que
<=	Menor o igual

Lógicos

Permiten unir condiciones lógicas (que devuelven verdadero o falso).

Operador	Operación
and	And lógico
or	Or lógico
!	Negación

Concatenación (.)

Sirve para concatenar cadenas.

Ej:

Operador de asignación (=)

Sirve para asignar valores a variables. No debe confundirse con el operador de comparación (==).

$variable=valor;

Se puede usar combinado con los operadores aritméticos y con el operador de concatenación.

Ej:

Suma:

Equivalente a : $numero1 = $numero1 + 3;

Resultado: 8

Resta:

Equivalente a: $numero1 = $numero1 - 3;

Resultado: 2

Producto:

Equivalente a: $numero1 = $numero1 * 3;

Resultado = 15

División:

Equivalente a: $numero1 = $numero1 / 3;

Resultado: 1.6666666666667

Resto:

Equivalente a: $numero = $numero % 3;

Resultado: 2

Concatenación:

Equivalente a: $cadena = $cadena . "Mundo";

Resultado: Hola Mundo

Curso on-line Java 2 SE

noreply@blogger.com (ADA) — Wed, 10 Apr 2013 18:45:00 +0000

¡¡CONCURSO MINI PC ANDROID!!

noreply@blogger.com (ADA) — Sun, 07 Apr 2013 17:41:00 +0000

Leotec Android TV 4.0 4GB USB

Convierte tu televisor en un completo sistema multimedia con este dispositivo: vídeos, imágenes, aplicaciones Android y juegos de Google Play, etc.

Especificaciones:

Memoria RAM 1GB DDR3.

Almacenamiento interno 4G.

Conectividad WI-FI 802.11 b/g/n a Internet.

Conexiones:

Mini USB 2.0 para conectarlo con el ordenador y poder intercambiar archivos.
USB 2.0 para conectar teclado, ratón, dispositivos de almacenamiento externo, etc.
Conexión HDMI Full HD 1080p.
Slot micro SD

¡¿Quieres uno?!

Pues es muy fácil. Para poder participar en el sorteo solo tienes que seguirme aquí en el blog y en twitter y retwittear el twit del concurso. ¿Ya lo has hecho? ¡Pues atent@! El día menos pensado, en el momento menos pensado publicaré un twit en el que pondrá "¡¿Quién quiere un mini PC Android?!". La primera persona (que me siga y me haya retwitteado) que responda a ese twit se lo lleva. ¡Así de fácil!

Control de flujo en Java

noreply@blogger.com (ADA) — Wed, 03 Apr 2013 18:35:00 +0000

Las sentencias de control de flujo son las encargadas de “guiar” al programa a lo largo de la ejecución permitiendo mostrar información, ocultarla o repetir instrucciones un número concreto de veces. Sin este tipo de instrucciones el programa sería totalmente lineal, complejo y muy limitado.

SENTENCIAS CONDICIONALES
Estas sentencias permiten evaluar condiciones lógicas o valores de variables y ejecutar o ignorar ciertas instrucciones dependiendo del valor que tomen dichas condiciones.
Son dos: if y switch.

IF
Evalúa una condición lógica y ejecuta un bloque de código si esta es cierta.
La sintaxis de esta sentencia es la siguiente:

//el código que está aquí se ejecuta siempre
if (condición) {

//bloque de instrucciones que se ejecutarán solo si la condición es cierta

}
//el código que está aquí se ejecuta siempre

La condición puede ser cualquier condición lógica.
El código encerrado entre llaves ({}) se ejecuta solo si se cumple la condición. Todo el código que se encuentra fuera de las llaves se ejecuta siempre ya que no depende de la condición.

Ej: Supongamos que vamos a una fiesta. En la entrada del bar hay un cartel en el que pone “solo mayores de 18”

El programa nos preguntara nuestra edad, si somos mayores de edad la condición del if es cierta por lo que podremos entrar, disfrutaremos de la fiesta y al final nos iremos para casa:

Si somos menores (y respetamos las normas) no se cumplirá el if por lo que se saltará todo el código entre llaves y no podremos entrar, así que nos tendremos que marchar directamente:

Las instrucciones de preguntar la edad y de irnos a casa no dependen de que seamos mayores de edad puesto que en ambos casos se llevan a cabo, la condición solo nos impedirá disfrutar de la fiesta.

IF … ELSE
Hay casos en los que puede interesarnos ejecutar un código solo si se cumple y otro solo si no se cumple. Esto se puede conseguir utilizando la sentencia else:

if (condición){

//código que se ejecuta solo si se cumple

}else{

//codigo que se ejecuta solo si no se cumple

}

Al igual que antes todo lo que esté fuera de las llaves se ejecuta siempre.

Ej: Imaginemos que vamos a la misma fiesta pero, ahora hay un portero en la entrada que nos pregunta nuestra edad:

Si la edad introducida por el usuario es igual o superior a 18, igual que antes, se cumple la condición y podremos ir a la fiesta:

Si no es cierto, porque la edad es menor, no podremos entrar y se ejecutarán las instrucciones dentro de las llaves del else, el portero nos dirá que nos marchemos a nuestra casa:

SWITCH
La sentencia switch evalúa una variable. Dependiendo del valor que tenga ejecutará un código u otro.
La sintaxis de la sentencia switch es la siguiente:

switch (variable){

case valor1: //código para el valor1 break; case valor2: //código para el valor2 break; … case valorN: //codigo para el valorN break; [default: //codigo para el valor por defecto break;]

}

La variable tiene que ser de tipo entero o carácter. A partir de la versión 7 de java también se permite String (cadenas de caracteres).

Cada case dentro de las llaves representa uno de los posibles valores que puede tomar la variable. Si el valor de la variable encaja con alguno de los case se ejecutará el código de ese case hasta el primer break.

La instrucción break es necesaria para que se detenga la ejecución, en caso contrario se ejecutarían todos los casos posteriores al seleccionado.

La instrucción default no es obligatoria pero, de usarse, debe ir al final de todos los case. Es el valor por defecto, si ningún case tiene el valor de la variable se ejecutará el código de default.

Ej: Supongamos que queremos simular el comportamiento de una agenda. El programa pide al usuario un día de la semana y le dice las tareas que tiene programadas para ese día:

La instrucción scan.nextLine() lee una cadena de teclado. Al incluir .toLowerCase() la pasa entera a minúsculas para permitir al usuario introducir “MARTES”, “Martes”, “MaRtEs” o cualquier combinación de mayúsculas o minúsculas que quiera y que el programa siga funcionando.

El default se ejecutará si no se introduce un día valido, por ejemplo: “martesa”.

Si introducimos por teclado “martes” se ejecutará el segundo caso que es el que tiene ese valor:

SENTENCIAS REPETITIVAS
Las sentencias repetitivas permiten que unas determinadas instrucciones se ejecuten un número finito de veces.
Son tres: for, while y do ... while

FOR
El for es un bucle controlado por contador. Se repite el código encerrado entre llaves un número conocido de veces.

La sintaxis es la siguiente:

for (inicio; condición; incremento){

//codigo que se reptite

}

Inicio: La inicialización del contador con el valor desde el que empieza a contar. El contador debe ser una variable entera.

Condición: Es una condición lógica que debe cumplirse para que el bucle se repita. En algún momento debe dejar de cumplirse ya que sino el bucle se repetiría de forma indefinida y eso es un error muy grave, es lo que se llama bucle infinito.

Incremento: El incremento es el encargado de hacer que el contador aumente (o disminuya en algunos casos) su valor para que cuente las repeticiones y alcance el valor necesario para detener la ejecución del bucle.

Ej: El siguiente código imprime por pantalla la tabla de multiplicar del 2:

El bucle se repite 10 veces ya que empieza en 1 (int i=1) y se incrementa de uno en uno (i++). La condición indica que se repetirá mientras sea menor o igual que 10. Como i va aumentando llegará un momento en que superará el valor 10 y el bucle se detendrá.

Dentro del for la i va aumentando en una unidad su valor, por lo tanto, cada vez que se hace esta operación: “resultado = 2 * i” la constante 2 se multiplica por un número una unidad mayor que la vez anterior.

El resultado final es el siguiente:

Como se puede apreciar aparece la operación 10 veces (las repeticiones del bucle) y cada vez tiene el valor correspondiente al termino por el que se multiplica (i).

WHILE
La sentencia while también permite realizar repeticiones pero, en este caso, el número de repeticiones no tiene porqué ser conocido (entre 0 y n) aunque, al igual que ocurría con el for, debe ser un número finito.
La sintaxis es la siguiente:

while (condición) {

//codigo que se repite

}

Si la condición es cierta el bucle se repite. En algún momento debe dejar de ser cierta para impedir el bucle infinito.

Ej: Supongamos que queremos saber cuantas veces hay que multiplicar un número por si mismo para superar 3546:

“n” es el número que se quiere multiplicar.

“contador” es el encargado de contar las veces que se multiplica por si mismo. Inicialmente es 0 ya que no se ha empezado a hacer ninguna operación.

“producto” irá acumulando las operaciones. Empieza con el valor de n ya que es el número que se quiere multiplicar.

La condición del while indica que se repetirá el código del interior de las llaves mientras el producto tenga un valor inferior a 3546.

Dentro de las llaves se multiplica “producto”, que inicialmente vale 3 por “n” que es 3 y se vuelve a guardar en “producto” reemplazando el 3 que contenía por un 9. En la siguiente repetición “producto” vale 9, se vuelve a multiplicar por 3 y se vuelve a guardar en “producto” que pasa a valer 27 y así sucesivamente hasta alcanzar o superar el valor deseado que será cuando el bucle se detenga. Además, por cada repetición, el contador incrementa su valor en una unidad, por lo que al final su valor será el número de veces que se ha repetido el bucle para conseguir el resultado deseado:

DO ... WHILE
El funcionamiento es el mismo que el while, la diferencia es que este bucle se repite entre 1 y n veces. Se suele usar para validar datos.

La sintaxis es la siguiente:

do{

//código que se repite

}while (condición);

La instrucción do no impide el acceso al bucle en ningún caso, por lo que al menos una vez se ejecutará el código entre llaves.

El bucle se repite mientras la condición sea cierta, igual que en el while. Por supuesto, en este caso, también hay que evitar los bucles infinitos.

Este bucle es el único que termina en punto y coma (;).

Ej: Supongamos que queremos que el usuario adivine el número en el que estamos pensando. Al menos una vez se lo preguntaremos y si lo acierta no insistiremos más pero, si no lo acierta se lo volveremos a preguntar hasta que lo acierte:

El número que debe acertar es n, que vale 5. Siempre que introduzca un valor distinto a este, la condición “numero != n” se cumplirá por lo que el bucle se repetirá. Solo cuando lo acierte la condición dejará de ser cierta y el bucle se detendrá permitiendo ejecutar el código que hay después: “System.out.println (“Has acertado!!!”);”:

Operadores y expresiones en Java

noreply@blogger.com (ADA) — Thu, 28 Mar 2013 20:22:00 +0000

EXPRESIONES

Una expresión es un conjunto de variables, constantes y/ó funciones unidas mediante uno o varios operadores. El resultado será un único valor numérico, lógico o una cadena de caracteres. Si las expresiones son muy complejas se suelen encerrar entre paréntesis para distinguir el orden de ejecución de la misma. Lo que está entre paréntesis siempre es lo primero que se ejecuta ya que este operador es el más prioritario de todos.

Ej: x=5*(6+4);

En el ejemplo lo primero que se ejecuta es la suma ya que está entre paréntesis, si no estuviesen los paréntesis se ejecutaría primero el producto puesto que su operador es más prioritario.

En la siguiente tabla se muestra el orden de precedencia de los operadores ordenados de más a menos prioritario:

Máxima prioridad
Expresión	( ) [ ]
Unarios	- ! ++ --
Multiplicativos	* / %
Aditivos	+ -
De movimiento de bits	>> <<
Relacionales	< <= > >= == !=
Lógicos	& ^\| && \|\|
Condicionales	?
Asignación	=
Minima prioridad

En los puntos siguientes los explico con más detalle.

OPERADORES ARITMÉTICOS

Permiten realizar operaciones aritméticas con datos numéricos.

Operador	Descripción	Sintaxis
+	suma	valor1 + valor2
-	resta	valor1 – valor2
*	producto	Valor1 * valor2
/	división	Valor1 / valor2
%	módulo (resto división entera)	Valor1 % valor2
++	incremento	variable++ ó ++variable
--	decremento	Variable -- ó --variable
-	cambio de signo	-valor

Operadores suma, resta, producto, división y módulo

En el siguiente ejemplo se declaran dos números enteros con los que se realizan una serie de operaciones (suma, resta, producto, división y módulo). El resultado de cada operación se almacena en la variable resultado. Cada vez que se almacena un nuevo resultado se pierde el anterior por eso se imprime por pantalla antes:

la salida de este código es:

El resultado de dividir x (5) entre y (2) es 2. Esto se debe a que x e y son números enteros por lo tanto se hace la división entera. No queda exacta, sobraría uno. Se puede obtener ese dato con el modulo (%) que devuelve 1, ya que es lo que sobra de la división. Es el resto.

Si lo que se pretende es que el resultado sea un numero real, hay que usar variables reales para que el operador no realice una división entera:

El resultado será un numero real:

Operadores de incremento y decremento

Estos operadores son unarios o monarios. Esto significa que afectan a una única variable. Se pueden usar tanto delante (prefijo) como detrás (postfijo) de la variable sobre la que se quiere hacer la operación. El resultado será el mismo (incrementar o decrementar):

En la salida se puede ver que la y se ha ido decrementando en una unidad y la x incrementándose también en una unidad:

Hay que tener cuidado si se usan estos operadores en una asignación ya que el resultado cambiará si se usa el operador prefijo o el postfijo:

Salida:

Como se ve en la salida, el operador prefijo, primero modifica x y luego asigna el nuevo valor a y. En el caso del postfijo es al revés. Primero asigna el valor de x a y, luego modifica x. En los dos casos la variable a la que afecta el operador se ve afectada, la diferencia está en la variable a la que se le asigna el valor.

Operador de cambio de signo

El operador de cambio de signo es igual que el operador de resta, pero su funcionamiento es distinto. Al colocar este operador delante de una variable en una asignación hace que el dato guardado sea de signo apuesto al original:

Salida:

OPERADORES RELACIONALES

Permiten comparar dos valores numéricos o caracteres. Devuelven true o false en función de que la comparación sea cierta o falsa.

Operador	Descripción	Sintaxis
>	mayor exclusivo	Valor1 > valor2
<	menor exclusivo	Valor1 < valor2
>=	mayor o igual	Valor1 >= valor2
<=	menor o igual	Valor1 <= valor2
==	igualdad	Valor1 == valor2
!=	desigualdad	Valor1 != valor2

Un ejemplo con cada operador:

La salida de este código es:

NOTA: No hay que confundir el operador de igualdad (==) con el de asignación (=).

OPERADORES LÓGICOS

Permiten unir expresiones lógicas para evaluarlas en conjunto y saber si son true o false.

Operador	Descripción	Sintaxis
&&	conjunción (and)	Expresión && expresión
\|\|	disyunción (or)	Expresión \|\| expresión
!	negación (not)	! expresion

Las dos expresiones deben ser true para que la expresión completa sea true:

&&	true	false
true	true	false
false	false	false

Es suficiente que una de las dos expresiones sea true para que la expresión completa lo sea:

\|\|	true	false
true	true	true
false	true	false

Niega la expresión. El valor será el contrario:

!	true	false
	false	true

OPERADORES DE ASIGNACIÓN

Asignan el valor de la expresión de la derecha en la variable de la izquierda. Siempre se evalúa la parte derecha primero. No es una ecuación.

Operador	Descripción	Sintaxis	Equivalente a
=	asignación	variable=expresión
+=	suma	variable+=expresión	variable=variable+expresión
-=	resta	variable-=expresión	variable=variable-expresión
*=	producto	variable*=expresión	variable=variable*expresión
/=	división	variable/=expresión	variable=variable/expresión
%=	módulo	variable%=expresión	variable=variable%expresión

El resultado de la suma (x+y) se almacena en z:

El primer operador de la tabla es el de asignación, el resto son abreviaciones de expresiones más largas que contienen en la parte derecha la misma variable que se encuentra en la parte izquierda de la asignación:

OPERADOR ?

Sirve para realizar asignaciones condicionales. Es decir, se evaluará una expresión lógica y dependiendo de si es true o false se asignará un valor u otro. La sintaxis es la siguiente:

variable = expresión_logica ? valor_verdadero : valor_falso;

En el siguiente ejemplo se compran dos valores enteros. Si x es mayor que y entonces se guarda en resultado el primer valor (“X es mayor”) que se corresponde con el verdadero, sino se guarda el segundo (“Y es mayor”) que se corresponde con el falso:

El resultado es el siguiente:

OPERADORES A NIVEL DE BITS

Estos operadores trabajan desde el nivel interno de los datos, sus bits (0s y 1s). En computación el 1 representa un valor verdadero y el 0 un valor falso por lo que las operaciones que se realiza con ellos son logicas y funcionan de forma similar a las que se realizan con los operadores && (and) y || (or).

Operador	Descripción	Sintaxis
&	Conjunción de bits (and)	dato1 & dato2
\|	Disyunción de bits (or)	dato1 \| dato2
^	Disyunción excluyente de bits (xor)	dato1 ^ dato2
<<	Desplazamiento de bits a la izquierda	dato1 << numero_bits
>>	Desplazamiento de bits a la derecha	dato1 >> numero_bits
~	Complemento	~dato

En este post no los explicaré. Si le interesan a alguien puedo hacer un post solo para ellos porque son algo extensos de explicar.

OPERADORES CON OBJETOS

Existen otros operadores que se usan con objetos pero los explicaré más adelante. Son los tres siguientes:

instanceof

Este operador sirve para saber si un objeto es idéntico a una clase. Es muy útil en herencia.

this

Permite identificar la clase a la que pertenece un objeto.

new

El operador new sirve para reservar memoria e instanciar objetos.

Entrada y salida estándar en Java

noreply@blogger.com (ADA) — Sat, 23 Mar 2013 18:02:00 +0000

ESCRITURA DE DATOS EN LA CONSOLA DEL SISTEMA

PrintStream

La clase PrintStream permite dar formato a la salida.

Cuando la aplicación arranca, automáticamente se crea un objeto System.out que permite establecer comunicación entre la aplicación y el sistema operativo utilizando, para ello, los métodos de formato que proporciona la clase PrintStream:

print: envía cadenas de caracteres a la consola del sistema.

System.out.print (“cadena que se va a mostrar”);

La salida por consola sería:

La salida se muestra toda en la misma línea. Para que la salida del método print genere una nueva línea hay que incluir el carácter de salto de línea (‘\n’):

La salida de esta instrucción sería:

Este mismo resultado se puede obtener con el método println.

El método print se puede usar también para enviar a la consola cualquier tipo de dato:

Salida:

O combinación de datos utilizando el operador + para concatenarlos:

y su salida:

println: funciona igual que print solo que incluye un salto de línea tras la cadena automáticamente.

System.out.println (“cadena que se va a mostrar”);

La salida es la misma que en el caso del print, solo que no es preciso indicar el salto de línea ya que se incluye automáticamente.

printf: permite incluir formato en la salida generada utilizando mascarillas de formato:

System.out.printf (“cadena con mascarillas”, argumentos);

Las mascarillas son especificadores de formato que indican el tipo de dato que se quiere mostrar. Usándolos dentro de una cadena se puede definir el formato completo de la cadena y la colocación de los datos dentro de la misma:

Mascarilla	Tipo de dato que representa
B, b	boolean
H, h	cadena de caracteres en hexadecimal
S, s	cadena de caracteres
C, c	char
d	entero
o	valor numérico en octal
X, x	valor entero en hexadecimal
E, e	real con notación científica
f	coma flotante
G, g	coma flotante
A, a	coma flotante en hexadecimal
T, t	formato de fecha y hora

Las mascarillas hay que usarlas con el operador % y tienen el siguiente formato:

% [índice] [modificadores] [ancho] [numero_decimales] mascarilla

índice: número del argumento que tomará el valor especificado. El primero: 1$, el segundo 2$ y así sucesivamente. La lista de argumentos se incluye en la parte derecha de la función printf. Si no se indica el numero de argumento las mascarillas se aplican por orden:

En este ejemplo la mascarilla %d hace referencia a un número entero, como no se indica ningún número de argumento se aplicará al primero, la x. La segunda mascarilla representa un número real. Tampoco se indica número de argumento por lo que se aplicará al segundo argumento, la y.

La salida en la consola será la siguiente:

En el siguiente ejemplo se obtiene el mismo resultado pero incluyendo los índices de los argumentos:

Modificadores: Incluyendo un + se mostrará el signo. El signo negativo ( - ) siempre se muestra aunque no se ponga el modificador:

La salida de esta instrucción será la siguiente:

Ancho: Número mínimo de caracteres que se imprimirán. Si el dato los supera no se verá afectado, si no los alcanza se incluirán espacios en blanco por la izquierda hasta completarlos:

La salida en consola:

Numero de decimales: Esto solo se puede aplicar a datos con coma flotante. Indica el numero de decimales que se quieren imprimir. Hay que escribirlos precedidos por un punto ( . ):

En la salida se puede apreciar que el numero de decimales se ha reducido:

Todos los formatos se pueden combinar entre si para conseguir el resultado deseado:

Su salida será:

Existe otra versión de este método:

System.out.printf (Locale , “cadena con mascarillas”, argumentos);

Locale: Activa las características regionales de formato para números y fechas según la región lingüística. Este objeto lo explicaré más adelante junto con las fechas.

NOTA: La clase PrintStream se está empezando a reemplazar por la clase PrintWriter, ya que gestiona mejor los caracteres Unicode pero, a pesar de ello, se siguen usando los métodos de formato de la clase PrintStream sin que el compilador los identifique como obsoletos (deprecation).

LECTURA DE DATOS A TRAVÉS DE LA CONSOLA DEL SISTEMA

Hay dos formas de leer datos de teclado en java. La clásica consiste en utilizar las clases InputStreamReader y BufferedReader. La otra forma, más nueva, es usar la clase Scanner.

En ambos casos hay que seguir el paradigma fuente-flujo-filtro.

Fuente: origen de los datos

Flujo: medio para transportar los datos

Filtro: dispositivo de interpretación de los datos

InputSreamReader y BufferedReader

Al igual que el objeto System.out, existe un objeto System.in que se crea automáticamente al iniciarse la aplicación e identifica la consola como periférico de entrada.

En este caso, el objeto System.in será la fuente.

Del flujo de datos se encarga la clase InputStreamReader a la que se le indicará la fuente (System.in) en el momento de la creación del objeto correspondiente:

El flujo servirá como argumento para crear el filtro, un objeto de la clase BufferedReader que será el encargado de recuperar la cadena que introduce el usuario a través del teclado:

La clase BufferedReader proporciona un método readLine que recuperara todo el flujo de información en formato de cadena de caracteres (String):

En el siguiente ejemplo se le solicita al usuario su nombre. El objeto BufferedReader recuperará, con el método readLine, el flujo de bytes sin formato que se recoge de la consola a través del objeto InputStreamReader. Posteriormente transforma este flujo de información en una cadena de caracteres (String) que se almacena en el objeto nombre. Si se imprime este ultimo objeto con el método println, se podrá ver en la consola el dato que ha introducido el usuario:

Comentar un par de cosas más sobre este código. Para poder usar BufferedReader e InputStreamReader hay que importar el paquete java.io. Por eso se incluyen estas tres líneas al principio del código:

También se pueden reemplazar por esta otra que importaría el paquete completo y no solo las clases que se van a usar:

La segunda línea:

y la instrucción throws del main:

sirven para la gestión de excepciones. Siempre que se utilice el método readLine será necesario realizar esta operación o el programa no compilará.

La gestión de excepciones la trataré en profundidad más adelante.

La salida de este ejemplo sería:

El usuario escribe su nombre:

El programa le saluda:

NOTA: Si se quieren leer datos que no sean String, hay que parsearlos utilizando las clases envoltorio. Como ya dije en el post anterior, las explicaré más adelante.

Scanner

El otro modo de leer datos de teclado es usando la clase Scanner. Es mucho más simple de usar ya que no produce excepciones y la sintaxis es mucho más sencilla.

La fuente de datos sigue siendo System.in, puesto que es el objeto que identifica la consola pero, tanto el flujo como el filtro son cosa de Scanner.

En este caso también hay que importar el paquete java.io:

O solo la clase Scanner:

Scanner tiene el metodo nextLine que realiza la misma función que readLine de la clase BufferedReader.:

La salida de este programa será la misma que en el caso de usar BufferedReader y InputStreamReader.

Scanner, además de permitir leer los datos en formato String, proporciona otros métodos que permiten recuperar la información en otros formatos:

Metodo	Dato
nextByte()	byte
nextShort()	entero corto
nextInt()	entero
nextLong()	entero largo
nextFloat()	punto flotante simple precisión
nextDouble()	punto flotante doble precisión
nextBoolean()	booleano

Se usan igual que readLine pero cambiando el tipo de la variable que almacenará la información que se lee:

Tipos de datos y variables en Java

noreply@blogger.com (ADA) — Thu, 21 Mar 2013 14:56:00 +0000

TIPOS DE DATOS PRIMITIVOS

Datos simples ordinales (enteros)

Representan los datos enteros sin decimales

Tipo	Tamaño (bytes)	Descripción	Rango
byte	1	byte	-128 a 127
short	2	entero corto	-32768 a 32767
int	4	entero	-2³¹ a 2^31-1
long	8	entero largo	2⁶³ a 2^63-1

Ej: 1, 27, 5948272, 435623L

Los datos long deben incluir una L al final

Datos simples reales

Representan los datos con decimales o de punto flotante.

Tipo	Tamaño (bytes)	Descripción	Rango
float	4	real simple precisión	+-3.4X10³⁸ a +-1.4x10⁴⁵
double	8	real doble precisión	+-1.8x10³⁰⁸ a +-4.9x10^-324

Ej: 30.0, 5678.345

La coma decimal se representa con un punto ( . ), si se emplea una coma ( , ) no funcionará ya que la coma tiene otra funcionalidad que ser verá más adelante.

Para poder distinguir un float de un double hay que incluir las letras F o D al final del numero representado:

Double: 15.05D

Float: 15.05F

Por defecto en Java se emplea double por lo que la D no sería obligatoria.

Los datos reales también se pueden expresar en notación científica puesto que soportan rangos muy grandes de valores:

1234500000 -> 123.45E+7

O lo que es lo mismo: 123.45 x 10⁷

Datos de tipo carácter

Representan caracteres con formato unicode. Se representan entre comillas simples ( ‘ ).

Tipo	Tamaño (bytes)	Descripción	Rango
char	2	carácter	codificación Unicode

Ej: ‘a’, ‘5’ , ‘-‘, ‘@’

Existen unos caracteres especiales, o caracteres de control, no imprimibles que requieren una secuencia de escape representada con una barra inclinada ( \ ) . Igualmente se escriben entre comillas simples:

Carácter especial	Descripción
‘\n’	Salto de línea
‘\t’	Tabulador
‘\b’	Retroceso
‘\r’	Retorno de carro
‘\’’	Comilla simple
‘\\’	Barra inclinada
‘\”’	Comilla doble
‘\0’	Carácter nulo

Datos de tipo lógico

Representan valores lógicos. Estos valores cumplen el algebra de Bool, de ahí su nombre, y solo pueden tomar valores verdadero (true) o falso (false).

Tipo	Tamaño (bytes)	Descripción	Rango
boolean	1	booleano	true o false

VARIABLES

Un programa escrito en cualquier lenguaje maneja datos que son almacenados en memoria e identificados a través de un nombre simbólico. A estos datos se les llama variables o constantes, dependiendo de si su contenido es variante o fijo. Los datos almacenados en estas posiciones de memoria pueden ser de cualquiera de los tipos especificados anteriormente.

Identificadores validos

El nombre con el que se identifica una variable se llama identificador y debe cumplir una serie de normas para que sea valido:

- Debe empezar por una letra (a-z A-Z) ó por el carácter subrayado ( _ ) ó por el carácter $.

- No puede contener espacios.

- No se pueden usar las palabras reservadas como identificador:

abstract	continue	float	native	super	void
boolean	default	for	new	switch	volatile
break	do	goto	null	synchronized	while
byte	double	if	package	this
byteevalue	else	implements	private	threadsafe
case	enum	import	protected	throw
catch	extends	instanceof	public	throws
char	false	int	return	transient
class	final	interface	short	true
const	finally	long	static	try

Ej:

Identificador	Correcto
numero	si
$numero	si
índice	si *
nombre propio	no (no se pueden usar espacios)
nombre_propio	si
numero&letra	no (el & no es un carácter valido)
miIdentificador	si
MiIdentificador	si *

* El uso de tildes y mayúsculas está permitido, pero se desaconseja. Las tildes pueden dar problemas en algunos sistemas operativos. El uso de mayúsculas se recomienda para las clases y las constantes. Lo veremos más adelante.

NOTA: Java es un lenguaje casesensitive por lo que distingue identificadores escritos en mayúscula de los que están escritos en minúscula. No es lo mismo casa que Casa.

Declaración de una variable

Para poder usar las variables primero hay que declararlas. Cada variable se declara una única vez.

La declaración sigue la siguiente sintaxis:

tipo_de_dato identificador_valido[=inicialización];

El tipo de dato puede ser cualquiera de los existentes en Java.

El identificador estará definido cumpliendo las reglas expuestas anteriormente para que sea un identificador valido.

La declaración terminará en punto y coma ( ; ).

La inicialización no siempre es obligatoria. En el caso de inicializar la variable se usará el operador de asignación ( = ) seguido del valor con el que se desea inicializar la variable. Esta practica no se recomienda, salvo excepciones.

CONSTANTES

Las constantes representan variables que tienen un valor fijo que no puede modificarse.

Para representar una constante basta con incluir la palabra final antes de la declaración.

El identificador, por convenio, se escribe en mayúsculas.

El valor de la constante se suele incluir también en la declaración ya que no se podrá modificar posteriormente:

final tipo_de_dato IDENTIFICADOR_VALIDO = inicialización;

CADENAS DE CARACTERES (STRING)

Las cadenas de caracteres son conjuntos de caracteres unicode que se escriben de forma consecutiva entre comillas dobles ( “ ). Al ser objetos poseen funcionalidades propias para su manejo.

La sintaxis es la siguiente:

String identificador[=”inicialización”];

Las explicaré en profundidad más adelante.

OBJETOS DE CLASES ENVOLTORIO (WRAPPERS)

Todos los tipos de datos primitivos tienen una clase envoltorio asociada que les confiere funcionalidades más avanzadas.

Tipo de dato primitivo	Clase envoltorio
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

La sintaxis para definir un objeto de clase de envoltorio es la siguiente:

Nombre_de_wrapper identificador_valido[=inicialización];

VARIABLES DE REFERENCIAS

Contienen la dirección de memoria de un objeto.

Un objeto es un bloque de sentencias y datos generado a partir de una clase.

Estos términos, junto con las cadenas de caracteres y los wrappers, los explicaré con mayor detalle en otro post.

Ha fallecido Dennis Ritchie

noreply@blogger.com (ADA) — Thu, 13 Oct 2011 12:17:00 +0000

En 1972 Dennis Ritchie creó el lenguaje de alto nivel C con el que desarrolló posteriormente el sistema operativo Unix junto con Ken Thompson.

Podría decirse que Dennis Ritchie fue el padre de la informática moderna puesto que C sirvió como base de otros lenguajes modernos como Java y Unix fué el pie para desarrollar los sistemas operativos actuales.

Richie falleció hoy a los 70 años de edad a causa de una enfermedad.

DEP.

Ha fallecido Steve Jobs

noreply@blogger.com (ADA) — Thu, 06 Oct 2011 07:43:00 +0000

Esta mañana al encender mi Mac me he encontrado con esta imagen. Es cierto eso que dicen que una imagen vale más que mil palabras. Se me cortó la respiración al verla.

Tan solo un día después del lanzamiento del nuevo iphone 4s, Steve Jobs nos deja. Al final el cáncer le venció.

Es una de las pocas personas de las que se podría decir que ha hecho grandes cosas en la vida. Deja un gran legado y una marca muy onda en el mundo de las tecnologías.

Se ha ido un genio. ¿Qué será ahora de Apple sin el?

Cómo instalar Oracle 10g Express Edition

noreply@blogger.com (ADA) — Sat, 25 Jun 2011 20:07:00 +0000

A la hora de elegir una base de datos tenemos muchas alternativas: MySQL, Oracle, PostrgreSQL, etc. Como se suele decir, para gustos hay colores.

Si alguna vez habeis usado Oracle es posible que hayais tenido dificultades a la hora de instalarla, si no lo habíais hecho nunca antes. Para los que os interese esta base de datos, pero no la hayais usando antes, yo os recomiendo una versión mucho más sencilla, tanto de instalar como de manejar, que es la 10g Express Edition. Evidentemente no es tan profesional como pueden ser otras versionesm ni tan potente, pero si os estais iniciando en este mundillo de las bases de datos y os interesa Oracle, sin duda esta versión es la idónea.

Para conseguirla os la podeis descargar de la pagina de Oracle. Al colocar el cursor sobre la pestaña Downloads se desplegará un menú con todos los productos que Oracle permite descargar clasificados por categorías. Dentro de Bases de Datos encontraremos la que nos interesa.

En la siguiente pagina os dejará elegir el sistema operativo (Windows o Linux).

Tras haber seleccionado la opción apropiada para nuestro sistema tendremos que aceptar el acuerdo de licencia para poder descargarla.

Y posteriormente seleccionaremos la base de datos que nos interesa según nuestras necesidades. La primera opción solo está en inglés, la segunda tiene más idiomas (entre ellos el español, está será la que seleccionemos) y la ultima es un cliente para poder acceder a nuestra base de datos desde otras maquinas.

Una vez elegida la base de datos llega una parte que no nos suele gustar, pero que Oracle obliga a hacer en todas sus descargas: Registrarnos. Es obligatorio, sino no podremos bajar nada de la pagina de Oracle. Si ya tenéis una cuenta, como es mi caso, no es necesario el registro, bastará con iniciar sesión. Si no la tenéis registraros y después iniciad sesión.

Una vez iniciada la sesión comenzará automáticamente la descarga. Pulsaremos en guardar para que se descargue en la ubicación que le indiquemos.

Tras seleccionar el directorio donde queremos que se guarde comenzará la descarga que tardará algunos minutos

Una vez descargada, ya podemos comenzar la instalación. Buscamos el archivo que se ha descargado y hacemos doble click en el. Si os ocurre lo que me ha pasado a mi, que no me dejaba abrirlo porque no sabía con que programa asociarlo, cambiadle en nombre y añadir al final .exe, con eso sería suficiente. Después de abrir el archivo pincharemos en ejecutar en la ventana que se nos abre.

Comenzará a cargar el asistente de instalación, tardará unos segundos

Los pasos para instalar son muy sencillos, prácticamente siguiente, siguiente, siguiente...

La primera ventana que nos aparece es el mensaje de bienvenida al asistente de instalación. Pulsaremos en siguiente.

Después nos aparecerá el contrato de licencia. Lo aceptaremos y pulsaremos siguiente.

El siguiente paso es seleccionar el directorio donde queremos instalar Oracle. Podeis dejar por defecto el que viene o poner vostros el que querais. Yo dejaré el que viene por defecto que es C:\oraclexe\. Pulsamos siguiente.

Este paso es muy importante, probablemente el más importante de toda la instalación. Aquí debéis elegir una contraseña para el administrador de la base de datos. Elegid una contraseña que luego recordéis puesto que sin ella no podréis conectaros cuando vayáis a usar la base de datos. Recordad que el administrador es SYS o SYSTEM. Tras elegir la contraseña pulsamos siguiente.

Antes de comenzar la instalación nos mostrará la información de los puertos necesaria para administrar la base de datos (8080 por defecto) y establecer las conexiones (1521 por defecto). Es posible que el puerto 8080 ya lo esté usando otra aplicación como puede ser un servidor web. Si esto nos llegase a ocurrir podremos cambiarlo.

Pulsamos instalar.

Comenzará la instalación. No suele tardar mucho, eso ya depende de vuestro ordenador.

Una vez instalado nos aparecerá un mensaje que así lo indique. Si nos fijamos aparece un tick en Iniciar la página inicial de la base de datos. Podemos dejarlo activado y al dar a terminar se arrancará el explorador donde se abrirá la pagina de administración de la base de datos.

Siempre que necesitemos realizar alguna tarea de administración tendremos que abrir esta página en el explorador. Podremos acceder a ella escribiendo http://localhost:8080 y una vez en ella podremos entrar con el usuario SYSTEM y la contraseña que configuramos durante la instalación de Oracle.

En un post posterior os explicaré con más detalle la administración de la base de datos.

Cómo configurar un objeto DataSource con GlassFish

noreply@blogger.com (ADA) — Fri, 06 May 2011 17:55:00 +0000

Si estáis trabajando con aplicaciones web con servlets y bases de datos os puede resultar muy útil usar con contenedor de datos. En posts anteriores os expliqué como utilizar el Apache Tomcat. Existen otros contenedores como Weblogic de Oracle o GlassFish, entre otros.

En esta ocasión explicaré como configurar un Objeto DataSource con GlassFish server 3, que será muy útil a la hora de utilizar bases de datos en nuestra aplicación web.

Para acceder a la consola de administración* de GlassFish basta con escribir en el explorador: http://localhost:4848 (El puerto 4848 es el que se asigna por defecto cuando se instala, si lo habéis cambiado tendréis que poner el que definieseis).

Os aparecerá algo como esto:

En la parte izquierda aparece un menú con todas las opciones de administrador que ofrece GlassFish. En nuestro caso nos interesa configurar un recurso nuevo (un objeto DataSource) que usaremos con el API JDBC de Java por lo que seleccionaremos Recursos y dentro JDBC. Nos aparecerán dos directorios: Recursos JDBC y Conjunto de conexiones:

Conjunto de conexiones

El primer paso es crear un Conjunto de conexiones nuevo, por lo tanto seleccionaremos el segundo directorio. Nos aparecerán en el lado derecho todos los conjuntos de conexiones configurados en el servidor:

Para crear una nueva pulsamos en Nuevo... Nos aparecerá el primer paso de la configuracion:

En el campo nombre escribiremos el nombre que queramos darle al conjunto de conexiones y que más tarde usaremos para inicializar el DataSource.

En el Tipo de recurso seleccionaremos javax.sql.DataSource

Y por ultimo el Proveedor de la base de datos será el que vayamos a usar para nuestra aplicación web (Ej: Oracle, MySql, Postgresql, etc.)

Una vez fijados los campos, en la esquina superior derecha pincharemos en Siguiente y nos aparecerá el paso 2 para continuar con la configuración del conjunto de conexiones:

Configuración general:

Activaremos el Ping y lo demás quedará como está.

Configuración del conjunto:

Dejaremos los valores por defecto.

Transacción:

También dejaremos la configuración por defecto.

Propiedades adicionales:

El ultimo apartado nos servirá para indicar los datos de conexión con nuestra base de datos. Este paso se puede hacer de diferentes formas y funcionaría a la perfección. Os voy a contar dos alternativas:

Rellenar campos de la url por separado:

Para establecer una conexión con nuestra base de datos nos hacen falta tres cosas: url de la base de datos, el usuario y la contraseña. La url está compuesta por una serie de elementos (puerto, servidor, base de datos, etc.) que variarán en función de la base de datos que usemos (oracle, mysql, etc.). Si no conocemos o no sabemos como escribir la url pero si conocemos la información de la que está compuesta bastará con indicarle a GlassFish ésta información por separado.

Rellenar la url completa:

Si conocemos la url o sabemos como definirla, en lugar de incluir los elementos por separado podemos pulsar en agregar propiedad (en el caso de que no exista la propiedad url) y añadirla junto con los campos user y password.

Puede que GlassFish os añada propiedades adicionales a las anteriormente citadas. En principio no serían necesarias por lo que las podéis eliminar.

Una vez hecho todo esto le damos a finalizar y nos creará el conjunto de conexiones que aparecerá en la lista con todos los demás. Para comprobar si lo hemos configurado bien basta con abrirlo pinchando en el y el la pestaña General pinchamos en Sondeo. Si todo ha ido bien deberá aparecer el pensaje "Ping realizado con exito".

Recurso JDBC

Llegados a éste punto ya tenemos el DataSource creado. Ahora nos tendremos que crear un recurso JDBC para poder usarlo desde nuestra aplicación. Para ello entraremos en el menú de la parte izquierda mencionado anteriormente entraremos en Recursos JDBC.

Seleccionaremos Nuevo..

Para crear el nuevo recurso son necesarios dos simples pasos:

Primero le pondremos nombre al recurso (Nombre JNDI) con la siguiente sintaxis: jdbc/nombreDataSource

nombreDataSource tendrá que ser el del DataSource creado en el apartado anterior.

El segundo paso es indicar el nombre del conjunto de conexiones, que será el de nuestro DataSource.

El resto de campos que aparecen los dejaremos por defecto como están.

Y ya está. Ya tenemos un DataSource configurado y listo para usar en nuestras aplicaciones web con java y servlets.

*NOTA: Para poder acceder a la consola de administración previamente tendréis que haber arrancado GlassFish

Como usar MASM y debug

noreply@blogger.com (ADA) — Thu, 24 Feb 2011 11:02:00 +0000

El Microsoft Macro Assembler (MASM) es el ensamblador de Microsoft para la familia de microprocesadores x86. Este ensamblador fue pensado para sistemas de 16 y 32 bits, no se desarrollaron dos aplicaciones separadas para estos sistemas. Más tarde se desarrollaron versiones que permitían crear aplicaciones para Windows, pero la versión que os voy a explicar yo solo sirve para MS-DOS. A nivel académico es una buena opción.

Para todo el tutorial usaré el código del programa suma.asm que muestro a continuación. Podéis bajarlo desde aquí.

Este programa suma dos vectores de hexadecimales y guarda el resultado en otro vacío.

Antes de empezar podéis descargaros el MASM aquí y descomprimir los dos archivos ejecutables (MASM.EXE y LINK.EXE) en el mismo directorio donde guardéis el código .asm.

MASM

Entramos en el directorio donde esté nuestro fichero .asm (en nuestro caso suma.asm) y el ensamblador (MASM.EXE y LINK.EXE)

Una vez ahi, procedemos a ensamblar el archivo con la herramienta MASM escribiendo en la linea de comandos masm (para nuestro ejemplo masm suma.asm)

A continuación nos pedirá el nombre del fichero .obj, por defecto se llamará igual que el fichero .asm (le damos a intro porque queremos que se llame igual)

Le volveremos a dar dos veces más a intro puesto que nos pedirá otras dos cosas que nos interesan. Si todo ha ido bien el ensamblado nos devolverá 0 errores y 0 warnings (los warnings en ensamblador también son errores por lo que no puede haber ninguno) y se generará el código .obj en el mismo directorio en el que estamos.

Una vez que hemos ensamblado hay que linkar el código .obj que se habrá generado en el paso anterior. Para ellos usaremos la herramienta LINK escribiendo en la línea de comandos link (en nuestro caso link suma.obj). Nos pedirá el nombre del archivo .exe que nos generará (por defecto nos pondrá el mismo nombre que el .obj, en nuestro caso suma.exe). Como queremos que se llame igual simplemente le damos a intro.

A continuación le volveremos a dar otras dos veces a intro puesto que nos volverá a pedir otras dos cosas que no nos interesan.

Una vez que hemos terminado el linkado se habrá generado el archivo .exe. para ejecutarlo simplemente escribimos el nombre del archivo en la línea de comandos (suma.exe). En nuestro caso no se mostrará nada por pantalla puesto que el ejemplo suma.asm solo suma vectores y no imprime nada por pantalla.

Con esto no sabemos con seguridad si ha salido todo bien o no, lo que tenemos que hacer es usar la herramienta DEBUG de MS-DOS.

DEBUG

Para comprobar si el ensamblado y linkado han salido bien utilizaremos el debuger de MS-DOS escribiendo en la línea de comandos debug (en nuestro caso: debug suma.exe). Después de darle a intro nos aparecerá un guión para que pulsemos una de las opciones del debuger.

si escribimos ? y pulsamos intro nos aparecerá el menú con todas las opciones que nos permite el debuger. Las que nos interesan son t, g y q. A continuación las veremos con más detalle.

Si elegimos t ejecutará una instrucción de nuestro código .asm mostrando el estado de todos los registros del microprocesador 8086 antes de la ejecución de la misma. Cada vez que pongamos t ejecutara una instrucción por orden mostrando el estado de los registros antes de la misma, es decir, el estado de los registros de la instrucción anterior. Es recomendable tener el código delante para asegurarnos que hace lo que queremos y darnos cuanta de lo que está mal en caso contrario.

Si queremos ejecutar más de una instrucción a la vez y ver sus registros pulsaremos t seguida de un numero (en la imagen siguiente he pulsado t3)

Si queremos terminar la ejecución de nuestro programa pulsaremos g. Esto terminará las instrucciones que quedan pero no mostrará el contenido de los registros. Si todo va bien nos mostrará un mensaje: "El programa ha terminado de forma normal"

Para salir del debuguer pulsaremos q y volveremos a la línea de comandos de MS-DOS

Como ya expliqué anteriormente podremos ejecutar nuestro programa escribiendo en la línea de comandos suma.exe

Cómo se usa el paso por valor y por referencia en C

noreply@blogger.com (ADA) — Sun, 23 Jan 2011 00:03:00 +0000

Retomando el post anterior, os voy a explicar como se usan funciones en C.

Como ya dije en el post anterior, una función se compone de dos partes (cabecera y cuerpo) que más o menos expliqué en el post anterior, pero queda aclarar un "pequeño" detalle bastante importante.

Parámetros formales

Como ya explique, las funciones puedes recibir parámetros en el momento de la llamada. Estos parámetros son variables de algún tipo definido en C.

Hay dos formas de pasar parámetros a una función, bien pasando el valor de la variable o bien pasando la dirección de memoria de la misma. A estas formas de pasar parametros se las conoce como paso por valor y paso por referencia respectivamente.

Paso por valor

En el paso por valor se pasa directamente el valor con el que queremos trabajar, en este caso solo se tendrá acceso a dicho valor y en el caso de cambiarlo dentro de la función, al terminar esta y volver al punto del programa desde donde se invocó, la variable que se pasó como parámetro no se habrá modificado.

int suma (int a, int b){

a=4;

return a+b;

}

La función suma recibe dos parámetros de tipo int y devuelve la suma de ambos, que también es un dato de tipo int (se especifica al principio de la cabecera).

void main(){

int a=2;

int b=3;

printf("%d",a); -> ¿Cuánto vale a?

printf("%d", suma(a,b)); ->¿Cuál es el resultado devuelto por suma?

printf("%d",a); -> ¿Cuánto vale a?

}

En la función main se declaran dos variables enteras a y b con valores 2 y 3 respectivamente.

En el primer printf se imprime el valor de a que, como no ha sido modificada desde su inicialización, será 2.

En la siguiente linea se imprime el valor retornado por la función suma definida antes. Si analizamos la función suma veremos que el valor de a se ha cambiado, por lo que la función devolverá 4+3 (o lo que es lo mismo, 7).

En la última linea se muestra de nuevo el valor de a pero, ¿cuál es? Dentro de la función suma se modificó el valor y esto afectó a la operación pero, una vez que la función termina y volvemos al lugar de la llamada ese cambio deja de tener efecto sobre a ya que se le pasó a suma por valor, por lo que el valor de a sigue siendo el mismo que cuando se inicializó: 2.

Paso por referencia

En el paso por referencia lo que recibe la función ya no es un valor, sino una dirección de memoria.

Veamos el ejemplo anterior.

int suma (int *a, int *b){

*a=4;

return *a+*b;

}

Si os fijáis, hay una pequeña variación con respecto a la función suma anterior. Ahora los parámetros tienen un *. Esto significa que son punteros (se verán con mas detalle).

Al pasar punteros las modificaciones que se realicen dentro de la función permanecerán cuando esta termine y retorne al lugar de la llamada, porque ahora lo que se está modificando no es el valor, sino el contenido de la dirección de memoria donde apunta el puntero. Pero ¿qué pasa si se quita el *?

int suma (int *a, int *b){

a=4;

return a+b;

}

Si no pusiésemos el * lo que estamos haciendo es modificar las direcciones de memoria de las variables, lo que producirá resultados inesperados. El * nos indica que accedemos al contenido de la dirección de memoria, es decir, al valor de la variable. Hay que tener mucho cuidado con esto.

void main(){

int a=2;

int b=3;

printf("%d",a); -> ¿Cuánto vale a?

printf("%d", suma(&a,&b)); ->¿Cuál es el resultado devuelto por suma?

printf("%d",a); -> ¿Cuánto vale a?

}

En la llamada a la función también hay una pequeña variación. Hay que incluir un & antes de los parámetros pasados por referencia. Al poner el & lo que estamos haciendo es pasar la dirección de memoria de la variable. De este modo la salida por pantalla será la siguiente:

En el primer printf se mostrará un 2, que es el valor de inicialización de a.

En el segundo printf se mostrará el valor retornado por la función suma: 7

El ultimo printf mostrará de nuevo el valor de a pero, en este caso, el valor habrá cambiado puesto que en la función se modificó, y al pasar a por referencia, el cambio se hace permanente, por lo tanto esa linea imprimirá un 4.

NOTA: Los arrays siempre se pasan por referencia por lo que no hay que especificarlo poniendo * y & (más adelante se explicará con más detalle).

Primeros pasos en C

noreply@blogger.com (ADA) — Sat, 11 Dec 2010 12:07:00 +0000

Porque todos hemos sido novatos en esto de la programación, este post va dirigido a todos los que están empezando a programar y están un poco perdidos.

El lenguaje C, es un lenguaje de alto nivel creado en 1972 para implementar sistemas operativos, aunque no creo que ninguno de vosotros tenga intención de usarlo para eso ^^

Antes de ponernos a programar como locos, hay que tener en cuenta una serie de cosas:

El compilador

Es un programa que necesitaremos para transformar nuestro código fuente (el programa que haremos en C) a código maquina (el lenguaje que entiende nuestro ordenador).

Existen muchos compiladores, la elección depende de vosotros (bueno y de vuestro sistema operativo, pero eso como cualquier programa).

Yo usaré el gcc de mi Mac OS X, es decir, compilare mediante comandos con el terminal.

La estructura de un programa en C

Una vez que hemos elegido la herramienta de desarrollo que usaremos, ahora es cuando podemos empezar a programar, pero no al tun tun. Primero tendremos que saber que es lo que vamos a hacer y para ello lo primero es conocer la estructura que tiene un programa en C.

Directivas del preprocesador

Son una colección de instrucciones especiales que se ejecutan al principio de la compilación.

Las mas habituales son:

#include: incluir ficheros de cabecera

Existentes en el compilador: #include < nombreFich.h>

#include < stdio.h>

Existentes en el directorio actual (pueden ser ficheros propios): #include "nombreFich.h"

#include "misFunciones.h"

#define: definir constantes

#define identificador valor

#define pi 3.1416

NOTA: Un identificador valido es una secuencia de letras, números y subrayado que siempre empieza por letra. Distingue entre mayúsculas y minúsculas. Se aplica esta norma tanto a constantes, como a variables, nombres de funciones, etc.

Declaraciones globales

Declaraciones accesibles desde cualquier punto del programa. Pueden ser variables o prototipos de funciones.

Variables: Representan información que varía durante la ejecución, de ahí su nombre

tipoDato idVariable nombre=valor;

int numero=10;

No es obligatorio inicializarlas en la declaración:

int numero;

Tipos de datos simples:
- Enteros:
int: -32768 - 32767
unsigned int: 0 - 65535
short int: -128 - 127
long: -2147483648 - 2147483647
unsigned long: 0 - 4294967295
- Reales
float: 3.4 x 10^-38 - 3.4 x 10^38 (precision 7 digitos)
double: 1.7x10^-308 - 1.7x10^308 (precision 15 digitos)
long double: 3.4x10^-4932 - 3.4x10^4932 (precision 19 digitos)
- Caracteres
char: 0 - 255
- Lógicos
Verdadero o falso: se representa con un dato de tipo int (1:verdadero, 0:falso)

Prototipos de funciones: Son las cabeceras de las funciones (ver Declaración de otras funciones) seguidas de ;

Función main

Punto de entrada al programa. Solo puede haber una.

void main()

{

//bloque de sentencias

}

void: significa que no devuelve nada.

Otra forma de escribir la función main es esta:

int main()

{

//bloque de sentencias

return 0;

}

en este caso main devuelve un int por lo que al final del método habrá que hacer un return (ver Declaración de otras funciones)

Declaración de otras funciones

Las funciones son conjuntos de sentencias que realizan una función. Mejoran la legibilidad, depuración y mantenimiento de los programas.

Las funciones tienen dos partes: cabecera (corresponde con el prototipo) y cuerpo.

tipoDevuelto idFuncion (parametrosFormales)//cabecera de la función

{

//aqui empieza el cuerpo

//sentencias

return expresion;

}

Una función termina cuando se encuentra un return, si no hay return termina cuando acaba el cuerpo.

Tipo devuelto: puede ser cualquiera de los tipos fundamentales explicados anteriormente. Si no devuelve nada se usa void. . Para devolver un valor a la función se usa return.

int suma ()

{

...

return expresion; //el tipo de la expresión tiene que coincidir con el tipo devuelto

}

void suma()

{

...

}

Identificador: debe cumplir las restricciones de los identificadores expuestas anteriormente.

Parámetros formales: Son opcionales, puede que la función no reciba nada en la llamada. En el caso de que se pongan, hay que especificar el tipo de cada uno de ellos.

int suma (int a, int b)

{

...

}

Las funciones las explicaré con más detalle en post futuros.

Cómo compilar y ejecutar un servlet en Tomcat

noreply@blogger.com (ADA) — Tue, 07 Dec 2010 16:10:00 +0000

Si os fue bien la instalación y configuración de Tomcat en Mac OS X ha llegado el momento de programar un servlet.

Estoy segura que hay montones de herramientas para hacerlo, pero después de haberme pegado con unas cuantas y ver que los resultados no eran muy buenos, os voy a contar cual es la solución más fácil que he encontrado y que por supuesto funciona.
Antes de empezar, para los que no lo sepan, un servlet es una clase en java que necesita un contenedor de servlets para funcionar. Puede que así dicho no quede muy claro. Si pensáis en el típico proyecto en java, solo necesitáis compilarlo y ya estaría listo para su ejecución. Un servlet, en cambio, después de su compilación necesita un contenedor de servlets (en nuestro caso Tomcat) para poder ser ejecutado, y eso es lo que yo os voy a explicar hoy, como compilar esa clase java y ejecutarla después desde Tomcat.

Lo primero de todo (después de instalar Tomcat y configurarlo) es crear un directorio donde colocar los servlets. Tomcat tiene, dentro de su directorio raiz, un directorio llamado webapps (/usr/local/apache-tomcat-6.0.29/webapps). Ahí es donde crearemos nuestros servlets, pero no podemos ponerlos de cualquier forma, es importante que cumplan una estructura determinada, sino Tomcat no los reconocerá. La estructura que tendrá nuestro directorio de servlets será la siguiente:

Proyecto:
El proyecto será el directorio que contedrá, como su nombre indica, todo el proyecto. Es un directorio que crearemos dentro de webapps y por supuesto lo podéis llamar como queráis. Si lo hacéis mediante la consola bastará con escribir esta linea:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales

Como podéis ver yo lo he llamado tutoriales.
Aquí dentro podéis poner paginas estáticas (html) o paginas dinámicas JSP, pero nada más, los servlets irán en otro sitio.

WEB-INF:
Este directorio hay que crearlo dentro de nuestro proyecto, contendrá otro subdirectorio classes con todos los servlets y el fichero web.xml que luego explicaré con detalle lo que es.
Para crear WEB-INF bastará con escribir en la consola:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales/WEB-INF

e inmediatamente podemos crear el directorio classes que contendrá los servlets:

mkdir /usr/local/apache-tomcat-6.0.29/webapps/tutoriales/WEB-INF/classes

Una vez hecho, prácticamente tenemos la estructura de nuestro proyecto, ahora empezaremos a programar. Yo he optado por usar el editor vi como os explique en post anteriores, pero podéis usar el que queráis.
Crearemos nuestro primer servlet que será el típico hola mundo y tendrá extensión .java:
Nos movemos al directorio del proyecto por comodidad:

cd /usr/local/apache-tomcat-6.0.29/webapps/tutoriales

y creamos el servlet:

vi HolaMundo.java

Tened cuidado con el nombre que le dais ya que tiene que coincidir con el nombre de la clase java que vamos a implementar dentro del servlet (java distingue entre mayúsculas y minúsculas)
El contenido de nuestro servlet será el siguiente:

Guardamos y cerramos pulsando esc :wq
Una vez guardado el servlet hay que compilarlo utilizando el api para servlets incluido en Tomcat (que se encuentra en la ruta /usr/local/apache-tomcat-6.0.29/lib/servlet-api.jar), para ello escribimos la siguiente linea:

javac -classpath /usr/local/apache-tomcat-6.0.29/lib/servlet-api.jar HolaMundo.java

Tras compilar, si todo ha ido bien, se generará un archivo HolaMundo.class que contendrá el servlet ya compilado. Este archivo hay que cambiarlo al directorio classes que creamos dentro de WEB-INF. Si lo hacéis por consola, basta con escribir esta linea:

mv HolaMundo.class classes

web.xml:
Si habéis llegado hasta aquí ya casi tenemos el servlet listo para ejecutarlo en Tomcat, lo único que nos queda es indicarle al servidor donde se encuentran los servlets, para ellos crearemos dentro de WEB-INF un archivo xml con la siguiente estructura:

display-name: Nombre identificativo para todos los servlets del documento
description: Una descripción de los servlets
servlet: Descripción de un servlet. Contiene dos elementos:
- servlet-name: Nombre del servlet
- servlet-class: Nombre de la clase del servlet, normalmente coincide con el nombre
servlet-mapping: Indica al servidor cómo se ejecuta un servlet en concreto. También tiene dos elementos:
- servlet-name: Nombre del servlet que queremos referenciar
- url-pattern: Ruta del servlet. Puede contener directorios virtuales. Será la ruta que usemos para lanzar el servlet con el Tomcat

Podéis crear este fichero con el vi como ya hemos visto.

Y una vez terminados todos estos pasos ya podemos arrancar Tomcat y probar el servlet. Arrancais Tomcat, abrís el explorador y escribís localjost:8080. Se os abrirá la página principal de Tomcat. Si pinchais en Tomcat Manager, en la parte izquierda (introducir user y pass), se os abrirá el gestor de aplicaciones web de Tomcat donde tendrá que aparecer el servlet que hemos creado:

Si os fijáis a la parte derecha del servlet aparece un menú como este:

Si el servlet no aparece como arrancado lo tenéis que arrancar, sino no funcionará.

Y llegó la hora de la verdad, para probar nuestro servlet escribiremos en el explorador la ruta que le indicamos en el documentos web.xml de la siguiente forma:
localhost:8080/tutorial/servlet/HolaMundo (o la ruta que hayáis puesto). Si todo ha ido bien deberiais ver en vuestro explorador algo como esto:

Cómo cambiar la contraseña de Tomcat en Mac OS X

noreply@blogger.com (ADA) — Sun, 05 Dec 2010 14:41:00 +0000

Si os fue bien la instalación de Tomcat que os expliqué en el post anterior, ya podreis usarlo y administrarlo escribiendo en vuestro explorador http://localhost:8080 y pinchando en alguna de las opciones que aparece en la parte izquierda de la pagina de inicio de Tomcat. Oh no!! me pide un usuario y una contraseña, pero no se cuales son :S

Seguro que a más de un@ os ha pasado eso. Que no cunda el pánico. Existe un fichero .xml en el directorio de Tomcat llamado tomcat-users.xml con esta estructura:

El fichero está en /usr/local/apache-tomcat-6.0.29/conf/tomcat-users.xml
Podeis abrirlo con el vi como os explique en el post anterior escribiendo en la consola:

vi /usr/local/apache-tomcat-6.0.29/conf/tomcat-users.xml

Simplemente tenéis que borrar los símbolos de comentario que os he marcado con unos asteriscos y definir un usuario nuevo con privilegios de administrador añadiendo estas lineas:

Los role y user que vienen definidos no hay que borrarlos, pero el que usaremos para entrar será el nuevo que hemos definido (el username y el password pueden ser el que queráis)

Finalmente lo guardais (si habéis usado el vi pulsais esc :wq) y volveis a arrancar el tomcat en vuestro explorador e intentais acceder con el user y password que habeis definido. Si todo ha ido bien os aparecerá el gestor de aplicaciones web de Tomcat.

Cómo instalar Apache Tomcat en Mac OS X

noreply@blogger.com (ADA) — Sun, 05 Dec 2010 12:24:00 +0000

Como inauguración de este blog, voy a enseñaros cómo instalar Tomcat en Mac OS X, ya que ayer mismo lo hice.
Tomcat, para quien no lo sepa, es un servidor web con soporte para paginas web dinámicas (servlets y JSP) y lejos de lo que pueda parecer, es muy fácil de instalar.

Antes de empezar teneis que descargaros Tomcat de la pagina oficial del proyecto. La descarga es gratuita por tratarse de software libre.
Como veréis (en la parte izquierda de la pagina) hay varias versiones. Yo voy a explicaros como se instala Tomcat 6.0, ya que la versión 7.0 es una beta.

Para Mac OS X teneis que bajaros el archivo .tar.gz

Una vez descargado el Tomcat, teneis que descomprimirlo, yo os recomiendo que lo hagáis a mano (donde queráis, simplemente haciendo doble click sobre el archivo .tar), también podríais hacerlo con la consola, pero yo os cuento la forma mas fácil de hacerlo y que menos problemas os puede dar.

Una vez hecho esto, abrís la consola para instalarlo (Aplicaciones/Utilidades/Terminal) y entrais en el directorio donde hayáis descomprimido el archivo. En mi caso, está en mi directorio Home, que es el que abre por defecto la consola.
El primer paso es mover la carpeta de tomcat al directorio /usr/local, para ello escribís las siguientes linea de comandos en la consola:

sudo sh: Con esta linea conseguís los privilegios de seguridad del root y ejecutamos comandos en un subsell. Nos pedirá la contraseña de administracion de nuestro equipo.

mv apache-tomcat-6.0.29 /usr/local: Con esta linea moveis la carpeta que contiene el Tomcat descomprimido al directorio /usr/local

Una vez hecho esto hay que dar privilegios, para ello escribís esta linea de comandos:
chmod -R 775 /usr/local/apache-tomcat-6.0.29

Y ya casi está, ahora solo queda configurar las variables de entorno, para ello os recomiendo crear un par de scripts donde las definis y además podéis arrancar o detener el Tomcat. Para crear los scripts, podéis hacerlos dentro de vuestro directorio Home con el editor vi (tenéis que cambiar de usuario, pasar de root a vuestro usuario, para eso simplemente escribís exit y le dais a intro).
Las variables a definir son estas dos:
CATALINA_HOME: Contendrá la ruta donde instalasteis el Tomcat
JAVA_HOME: Contendrá la ruta donde está instalado el JDK. Que nadie se asuste, en Mac OS X, el JDK ya viene instalado con el sistema. La ruta es /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home.
Por ultimo hay que indicar que quereis que Tomcat arranque o se detenga. Por tanto el script para arrancar Tomcat seria algo asi:

vi start_tomcat: esta linea abre el editor vi y crea un fichero llamado start_tomcat (podéis llamarlo como queráis)
y escribis esto:

#!/bin/sh
export CATALINA_HOME=/usr/local/apache-tomcat-6.0.29
export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
$CATALINA_HOME/bin/startup.sh

pulsamos esc :wq y ya tenemos el scipt de arranque

Para el sript que detiene Tomcat hay que hacer lo mismo (podéis llamarlo stop_tomcat o como queráis) pero el contenido del script será este:

#!/bin/sh
export CATALINA_HOME=/usr/local/apache-tomcat-6.0.29
export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
$CATALINA_HOME/bin/shutdown.sh

Ya solo nos queda el ultimo paso, que es darle permisos de ejecución:

chmod ug+x start_tomcat stop_tomcat (o como los hayáis llamado)

Ya podemos arrancar Tomcat escribiendo en la consola ./start_tomcat (o como lo hayáis llamado). Para comprobar que todo ha ido bien tenéis que abrir vuestro explorador de internet y escribir:
http://localhost:8080 y os tiene que aparecer una ventana como esta:

Si no os sale, revisar todos los pasos.

Para detenerlo igual que para arrancar pero con el otro script:
./stop_tomcat