.

Una variable se declara usando la misma sintaxis de C. Por ejemplo la siguiente

tabla indica una declaración, el nombre de la variable introducida y el tipo de
información que almacena la variable:

Declaración identificador tipo

int i; i entero
String s; s referencia a string
int a[]; a referencia a arreglo de enteros
int[] b; b referencia a arreglo de enteros

Java posee dos grandes categorías de tipos para las variables:

Tipos Primitivos referencias a Objetos

int, short, byte, long Strings
char, boolean Arreglos
float, double otros objetos

Las variables de tipos primitivos almacenan directamente un valor que siempre

pertenece al rango de ese tipo. Por ejemplo una variable int almacena un valor
entero como 1, 2, 0, -1, etc.

Esto significa que al asignar una variable entera a otra variable entera, se copia el
valor de la primera en el espacio que ocupa la segunda variable.

Las variables de tipo referencia a objetos en cambio almacenan direcciones y no

valores directamente. Una referencia a un objeto es la dirección de un área en
memoria destinada a representar ese objeto. El área de memoria se solicita con el
operador new.

Al asignar una variable de tipo referencia a objeto a otra variable se asigna la

dirección y no el objeto referenciado por esa dirección. Esto significa que ambas
variables quedan refenciando el mismo objeto.

La diferencia entre ambas asignaciones se observa en la siguiente figura:

Esto tiene implicancias mayores ya que si se modifica el objeto referenciado por
r, entonces también se modifica el objeto referenciado por s, puesto que son el
mismo objeto.

En Java una variable no puede almacenar directamente un objeto, como ocurre

en C y C++.

Por lo tanto cuando se dice en Java que una variable es un string, lo que se quiere
decir en realidad es que la variable es una referencia a un string.

Tipos primitivos

En la siguiente tabla se indica para cada tipo primitivo el número de bits que se
emplea en su representación y el rango de valores que se puede almacenar en las
variables de estos tipos.

Tipo Bits Rango Ejemplos

int 32 -2**31 .. 2**31-1 0, 1, 5, -120, ...
short 16 -2**15 .. 2**15-1 0, 1, 5, -120, ...
byte 8 -2**7 .. 2**7-1 0, 1, 5, -120, ...
long 64 -2**63 .. 2**63-1 0, 1, 5, -120, ...
 boolean 1 n/a false, true
char 16 n/a 'a', 'A', '0', '*', ...
float 32 IEEE 1.2
double 64 IEEE 1.2

Se dice que un tipo A es de mayor rango que un tipo B si A es un superconjunto

de B. Esto quiere decir que las variales de tipo B siempre se pueden asignar a
variables de tipo A (eventualmente con pérdida de significancia).

Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que
byte. Float y double son de mayor rango que int. Double es de mayor rango que
float.

Esto se puede resumir en:

double > float > long > int > short > byte

Expresiones

En Java cada expresión tiene un tipo que se determina durante la compilación, es

decir es independiente del valor durante la ejecución. Una expresión puede ser:

 Una constante: 1, 1.0, true, etc.

El tipo de esta expresión es el tipo de la constante. En el ejemplo los tipos

son int, double y boolean respectivamente.

 Una variable: i, s, a

El tipo de esta expresión es el tipo con que se declaró aquella variable. En

el ejemplo los tipos son entero, referencia a string y referencia a arreglo.

 El resultado de una operación: i+1, a[1], etc.

El tipo se determina en función de los tipos de las expresiones que se

indican como argumentos de la operación.

Java tiene prácticamente los mismos operadores de C y C++. Cada operador

acepta una, dos o tres expresiones de diversos tipos. A veces un operador no está
definido para argumentos de ciertos tipos. Por ejemplo la resta entre strings no
esta definida. Pero la suma de strings esta definida como la concatenación. A
continuación veremos los operadores más frecuentes en Java.

Operadores binarios entre expresiones numéricas

Símbolo Operación
+ Suma
- Resta
* Multiplicación
/ División
% Resto

Los operandos y el resultado de estos operadores pueden ser:

Dominio Rango
int*int int
long*long long
float*float float
double*double double

 Al operar con byte y short, estos se convierten implícitamente a int.

 Cuando los tipos de los operandos no coinciden, el operando de menor
rango se convierte implícitamente al tipo de mayor rango. El resultado de
la operación es del tipo de mayor rango.

Ejemplos:
int a=1, b=2;
int c= a + b;

short s= 1;
int d= s + c; // s se convierte a int

float f= 1.0 + a; // a se convierte a float

Operadores unarios sobre expresiones numéricas

Símbolo Operación Argumento

 + exp nada int | long | float | double
- exp cambio de signo int | long | float | double

El resultado de estas operaciones es siempre del mismo tipo del operando.

Si el operando es byte o short entonces se convierte a int, se realiza la operación

y el resultado es un int.

Operadores sobre variables enteras

Símbolo Operación Argumento

++ var preincremento int | short | byte | long
-- var predecremento int | short | byte | long
var ++ postincremento int | short | byte | long
var -- postdecremento int | short | byte | long

El resultado de estas operaciones es siempre del mismo tipo del operando.

Ejemplos:

int a=1, b=2;

int c= +a;
int d= -(c+1);

b= a++; // b= 1, a=2
a= --b; // a=b= 0

(a+1)++; // error a+1 no es una variable

float f= a;
f++; // error f no es entero

Operadores binarios relacionales

Símbolo Operación
> mayor
< menor
>= mayor igual
<= menor igual
 == igual
!= distinto

Los operandos y el resultado de estos operadores pueden ser:

Dominio Rango
int*int boolean
long*long boolean
float*float boolean
double*double boolean

Operadores entre valores booleanos

Operación Significado
exp && exp y-lógico
exp || exp o-lógico
! exp negación

Los operandos y el resultado de estos operadores son siempre booleanos.

Los operadores && y || evalúan la expresión del lado derecho sólo si es

necesario.

Ejemplos:

int a=1, b=2;

boolean v= ! a<=b && a==5 || b!=4;

boolean w= ((! a<=b) && a==5) || b!=4;

boolean w2= a<=b && a; // error a no es boolean

Conversiones: cast

 Java realiza conversiones implícitas de menor a mayor rango.

 Eventualmente hay pérdida de significacia al convertir enteros a punto
flotante.
  Todas las conversiones de mayor a menor rango deben ser explícitas por
medio del operador de cast:

(tipo)expresión

Ejemplos:
int i= 1;
short s= 2;
int j= i+s;

s= a; // error short < int

s= (short)a; // Ok

i= 1.0; // error int < double

i= (int)1.0; // Ok

f= 1.0; // error float < double

f= (float)1.0; // Ok
f= 1.0f; // Ok

boolean v=(boolean)a; // error no existe conversión

Precedencia de Operadores

. () []
unarios: - + (cast)
* / %
+ -
< > <= >= == !=
!
||
&&
Variables
Concepto

Las variables son un espacio o area de memoria dispuesta para almacenar

un valor para su posterior uso por el script, que tiene asignado un identificador
(nombre). El valor puede ser una cadena o un numero.

En php no hace falta declarar una variable antes de su uso, ni establecer su tipo. Su

nombre puede ser una combinacion de letras (a-Z), números y guiones bajos,
precedidos con el signo $. El primer carácter no puede ser un número, y php diferencia
entre mayusculas y minúsculas.
$var no es igual a $Var

Para utilizar una variable basta con asignarle un valor, usando para ello el operador =
Si el valor es una cadena, necesita ir entrecomillado.

<?php 
$ciudad = "madrid";     // el valor de ciudad es madrid 
$ciudad = "zaragoza";   // ciudad ahora es zaragoza 
$Ciudad = "barcelona";  // esta es otra variable distinta 
?>

Dependiendo de la información que contenga, tenemos diversos tipos de variables:

 integer contiene un número entero

 double contiene un número con decimales
 string una cadena de caracteres

<?php 
$int = 1;           // integro 
$doub = 1,5;        // double 
$string1 = "1";     // string 
$string2 = "uno";   // string 
$fecha = date(Y);   // tambien podemos asignar a variables el resultado d
e 
                    // una función. 
?>

Como ves, el valor de una variable ha de asignarse entrecomillado, salvo que se trate
de un valor numérico.
tipado (casting) de variables

Como hemos dicho, a diferencia de otros lenguajes, al declarar una variable no

tenemos que indicar a que tipo pertenece. Php lo hará por nosotros de acuerdo con su
contenido y el contexto. 

Aunque no es necesario, podemos especificar el tipo de la variable, o forzar su

conversion. Forzar un tipo de variable puede ser muy util, por ejemplo para validar la
entrada de datos por usuarios desde un formulario.

<?php 
$cadena="5";         //esto es una cadena 
$entero=3;           //esto es un entero 
echo $cadena+$entero //daria el resultado 8 

$mivar = "3";        // $mivar es tipo string  
$mivar = 2 + $mivar; // automaticamente se convierte a tipo integer 
                     // $mivar ahora vale 5 

$mivar = (string)123;// creamos $mivar como cadena 

settype($mivar, "double"); // forzamos su cambio a tipo double 
                           // el cambio forzado afecta al valor de la 
                           // variable: 
                           // $mivar = 3.5; 
                           // $mivar = (integer)$mivar; -> valor 3 
                           // $mivar = (boolean)$mivar; -> valor 1  
?>

Averiguando el tipo de una variable

Si necesitamos saber a que tipo pertenece una variable podemos usar la

función gettype():

<?php 
 $mivar = "123"; 
echo gettype($mivar); // string 
 $mivar = 123; 
echo gettype($mivar); // integer 

?>
Chequeando tipos concretos

Si lo que necesitamos es saber si se trata de un tipo concreto de variables, podemos

usar una funcion ad hoc: Todas ellas tomas como parámetro el nombre de la función a
chequear, y devuelvenverdadero o falso

Un dato importante a tener en cuenta es que una variable, sea cual sea su tipo, si es
pasada viaGET o POST automáticamente se convierte en tipo string. Por ello no
podremos utilizaris_integer, por ejemplo, sino is_numeric,, que no indaga acerca
del tipo de variable, sino acerca de los caracteres que la componen.

 is_array()
 is_bool()
 is_double()
 is_float()
 is_int()
 is_integer()
 is_long()
 is_null()
 is_numeric()
 is_object()
 is_real()
 is_resource()
 is_scalar()
 is_string()

valores por referencia

A partir de php 4 ademas de pasar un valor a una variable por asignación, podemos
pasarselo por referencia

Para ello creamos una nueva variable que referencia ( "se convierte en un alias de" o
"apunta a") la variable original. Los cambios a la nueva variable afectan a la original, y
viceversa. 

Para asignar por referencia, simplemente se antepone un ampersand (&) al comienzo

de la variable cuyo valor se está asignando.

<?php 

    $a = 5;         // $a vale 5 
    $b = &$a;       // $b vale 5   
    $b = $b + 3;    // $b vale 8. $a TAMBIEN vale 8 ahora.  
    /* los valores serán $a = 8 y $b = 8; */ 

?>
variables constantes

Son aquellas cuyo valor no va a cambiar a lo largo de la ejecución del script. Para
asignarles un valor se usa la función define()

<?php 
define ("AUTOR_EMAIL","blah@miemail.com"); 

echo AUTOR_EMAIL; // imprime blah@miemail.com 
                  // observa que las variables constantes 
                  // no necesitan del signo $ 
                  // Las constantes NO pueden ir entrecomilladas. 
?>

Podemos utilizar la funcion defined() para chequear si una constante esta definida o

no.

Por último, PHP ofrece diversas constantes predefinidas:

<?php 
                     
echo __FILE__ ."<br>";   // nombre del archivo 
echo __LINE__ ."<br>";   // numero de linea de codigo  
echo PHP_VERSION."<br>"; // numero de version php  
echo PHP_OS ."<br>";     // sistema operativo   
echo TRUE."<br>";        // valor verdadero (1)  
echo FALSE."<br>";       // valor falso (0 o cadena vacia)  
echo NULL."<br>";        // sin valor  

?>

Variables de variables

Podemos reutilizar el valor de una variable como nombre de otra variable

<?php 
$var = "ciudad";   // tenemos una variable var, valor ciudad  

$$var = "madrid";  // creamos una variable llamada ciud
Tipos de variables, características generales y aspectos específicos de
PHP de estos elementos básicos de la programación.
Por  Rubén Alvarez
Atención: Contenido exclusivo de DesarrolloWeb.com. No reproducir. Copyright.

Las variables son uno de los primeros temas que tenemos que conocer en PHP y en la mayoría

de los lenguajes de programación. Así que a continuación vamos a tratar este tema dentro

del Manual de PHP, explicando los tipos de variables que podremos encontrar.

Anteriormente en DesarrolloWeb.com, en el manual de páginas dinámicas, ya habíamos

introducido el concepto de variable. En el capítulo anterior comentábamos que, para PHP, las

variables eran definidas anteponiendo el símbolo dólar ($) al nombre de la variable que

estábamos definiendo.

Dependiendo de la información que contenga, una variable puede ser considerada de uno u otro

tipo:

Variables numéricas
Almacenan cifras
Enteros $entero=2002; Numeros sin decimales
Real $real=3.14159; Numeros con o sin decimal
Variables alfanuméricas
Almacenan textos compuestos de números y/o cifras
Cadenas Almacenan variables alfanuméricas $cadena="Hola amigo";
Tablas
Almacenan series de informaciones numéricas y/o alfanuméricas
$sentido[1]="ver";
$sentido[2]="tocar";
Arrays Son las variables que guardan las tablas $sentido[3]="oir";
$sentido[4]="gusto";
$sentido[5]="oler";
Objetos
Se trata de conjuntos de variables y funciones asociadas. Presentan una
complejidad mayor que las variables vistas hasta ahora pero su utilidad es
más que interesante.

A diferencia de otros lenguajes, PHP posee una gran flexibilidad a la hora de operar con

variables. En efecto, cuando definimos una variable asignándole un valor, el ordenador le

atribuye un tipo. Si por ejemplo definimos una variable entre comillas, la variable será

considerada de tipo cadena:

$variable="5"; //esto es una cadena

Sin embargo si pedimos en nuestro script realizar una operación matemática con esta variable,

no obtendremos un mensaje de error sino que la variable cadena será asimilada a numérica:

<?

$cadena="5"; //esto es una cadena

$entero=3; //esto es un entero

echo $cadena+$entero

?>

Ejecutar script

Este script dará como resultado "8". La variable cadena ha sido asimilada en entero (aunque su

tipo sigue siendo cadena) para poder realizar la operación matemática. Del mismo modo,

podemos operar entre variables tipo entero y real. No debemos preocuparnos de nada, PHP se

encarga durante la ejecución de interpretar el tipo de variable necesario para el buen

funcionamiento del programa.

Sin embargo, en contraste, hay que tener cuidado en no cambiar mayúsculas por minúsculas ya

que, en este sentido, PHP es sensible. Conviene por lo tanto trabajar ya sea siempre en

mayúsculas o siempre en minúsculas para evitar este tipo de malentendidos a veces muy

difíciles de localizar.

Variables asignadas por referencia

En PHP también podemos asignar variables por referencia. En ese caso no se les asigna un valor,

sino otra variable, de tal modo que las dos varialbles comparten espacio en memoria para el

mismo dato.

La notación para asignar por referencia es colocar un "&" antes del nombre de la variable.

<?php 

$foo = 'Bob'; // Asigna el valor 'Bob' a $foo 

$bar = &$foo; // Referencia $foo vía $bar. 

$bar = "Mi nombre es $bar"; // Modifica $bar... 

echo $foo; // $foo también se modifica. 

echo $bar; 

?>