domingo, 14 de abril de 2013

Introducción a PHP


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;
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
h o l a

m u n d o

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


domingo, 7 de abril de 2013

¡¡CONCURSO MINI PC ANDROID!!

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!

miércoles, 3 de abril de 2013

Control de flujo en Java


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!!!”);”:




jueves, 28 de marzo de 2013

Operadores y expresiones en Java


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.