Progra2 Libro

Curso dinámico de programación
El lenguaje PHP
PHP (acrónimo de "PHP: Hypertext Preprocessor") es un lenguaje interpretado de alto nivel

embebido en páginas HTML y ejecutado en el servidor.
Hay que entender primero como funciona la solicitud de páginas en un navegador para
comenzar a programar en PHP.
Comunicación entre el cliente y el servidor sin PHP:
1 - Tipeamos en la barra del navegador la dirección y el archivo a solicitar.

2 - El web browser (navegador) envía el mensaje a través de Internet a la computadora, por
ejemplo www.lanacion.com/pagina1.htm solicitando la página (archivo) pagina1.htm
3 - El web server (servidor web, que puede ser el Apache, IIS, etc.) que es un programa que
se ejecuta en la máquina www.lanacion.com, recibe el mensaje y lee el archivo solicitado
desde el disco duro.
4 - El servidor web envía el archivo solicitado por el navegador tal cual está en el disco
duro.
5 - El navegador muestra en pantalla el archivo que envió el servidor web.
Este proceso siempre es el mismo cuando hablamos de páginas estáticas (páginas que no
cambian), cualquiera sea el cliente que solicita la página el contenido siempre será el
mismo.
La única forma que el contenido del archivo cambie es que el administrador de ese sitio
web edite el contenido del archivo pagina1.htm y haga modificaciones.
Comunicación entre el cliente y el servidor con PHP:
1 - Tipeamos en la barra del navegador la dirección y el archivo a solicitar.

2 - El web browser (navegador) envía el mensaje a través de Internet a la computadora
llamada www.lanacion.com solicitando la página (archivo) pagina1.php
3 - El web server (servidor web, que puede ser el Apache, IIS, etc.), recibe el mensaje y al
ver que la extension es "php" solicita al interprete de PHP (que es otro programa que se
ejecuta en el servidor web) que le envíe el archivo.
4 - El intérprete PHP lee desde el disco el archivo pagina1.php
5 - El intérprete PHP ejecuta los comandos contenidos en el archivo y eventualmente se
comunica con un gestor de base de datos (ejemplos de ellos pueden ser MySql, MariaDB,
Oracle, Informix, SQL Server, etc.)
6 - Luego de ejecutar el programa contenido en el archivo envía éste al servidor web.
7 - El servidor web envía la página al cliente que la había solicitado.
8 - El navegador muestra en pantalla el archivo que envió el servidor web.
1
Tipos de variables
Los nombres de variables comienzan con el carácter $ y son sensibles a mayúsculas y

minúsculas (no así las palabras claves del lenguaje).
En PHP no es necesario definir el tipo de dato que almacena antes de utilizarla, las mismas
se crean en el momento de emplearlas. Las variables se declaran cuando se le asigna un
valor, por ejemplo:
$dia = 24; //Se declara una variable de tipo integer.

$sueldo = 758.43; //Se declara una variable de tipo double.
$nombre = "juan"; //Se declara una variable de tipo string.
$exite = true; //Se declara una variable boolean.
También podemos hacer notar que para disponer comentarios de línea debemos utilizar dos
caracteres //
Para la impresión de variables utilizaremos inicialmente el comando echo. Un programa

completo que inicializa y muestra el contenido de cuatro variables de distinto tipo es:
pagina1.php
<html>
<head>
<title>Problema</title>
</head>
<body>
<?php
$dia = 24; //Se declara una variable de tipo integer.
$sueldo = 758.43; //Se declara una variable de tipo double.
$nombre = "juan"; //Se declara una variable de tipo string.
$exite = true; //Se declara una variable boolean.
echo "Variable entera:";
echo $dia;
echo "<br>";
echo "Variable double:";
echo $sueldo;
echo "<br>";
echo "Variable string:";
echo $nombre;
echo "<br>";
echo "Variable boolean:";
echo $exite;
?>
2
</body>
</html>
Hemos utilizado un comando echo para mostrar los mensajes, otro el contenido de variables
y finalmente otro para imprimir un elemento HTML. Este proceso puede acortarse un poco
pero para que sea más claro inicialmente tomaremos el camino largo de hacer la impresión
de un dato con cada comando echo.
Ejercicio 1:
Definir una variable de cada tipo: integer, double, string y boolean. Luego imprimirlas en la
página, una por línea.
3
Variables de tipo string
Una variable de este tipo puede almacenar una serie de caracteres.
$cadena1="Hola";
$cadena2="Mundo";
echo $cadena1." ".$cadena2;
Para concatenar string empleamos el operador . (punto)
Tengamos en cuenta que el comando echo de más arriba lo podemos hacer más largo de la
siguiente forma:
echo $cadena1;
echo " ";
echo $cadena2;
A medida que uno haga ejercicios podremos resumir en un solo comando echo la salida de
múltiples variables.
Cuando una cadena encerrada entre comillas dobles contiene una variable en su interior,
ésta se trata como tal, por lo tanto se utilizará su contenido para el almacenamiento:
$dia=10;
$fecha="Hoy es $dia";
echo $fecha;
En pantalla se muestra: Hoy es 10
Es decir, en la cadena, se sustituye el nombre de la variable $dia, con el contenido de la

misma.
Una cadena se puede definir con las comillas simples (pero es importante tener en cuenta
que no se sustituyen las variables si empleamos comillas simples):
$nombre='Marco del Cid';
Veremos que en muchos casos se utiliza el concepto de sustitución de variables dentro de

un string en PHP por lo que nos acostumbraremos en un principio a utilizar las comillas
dobles para definir los string en nuestros programas.
4
Ejercicio 2:
Definir tres variables enteras. Luego definir un string que incorpore dichas variables y las
sustituya en tiempo de ejecución.
Recordar que una variable se sustituye cuando el string está encerrado por comillas dobles:
$precio=90;
echo "La computadora tiene un precio de $precio";
Estructuras de decisión
Cuando se pretende que el programa, una vez llegado a un cierto punto, tome un camino
concreto en determinados casos y otro diferente si las condiciones de ejecución difieren, se
utiliza el conjunto de instrucciones:
if, else y else-if. La estructura base de este tipo de instrucciones es la siguiente:
if (Condición)
{
Instrucción a1;
Instrucción a2;
}
else
{
Instrucción b1;
Instrucción b2;
}
Cuando la ejecución llega al punto donde se encuentra la instrucción if, el programa

verificará el cumplimiento o no de la condición. Si la condición es verdadera se ejecutarán
las instrucciones a1 y a2, de lo contrario, se ejecutarán las instrucciones b1 y b2.
En los casos en que las condiciones sean varias, se pueden utilizar los if de un modo
denominado anidado o anillado, como se indica de la manera siguiente:
if (Condición 1)
{
Instrucción a1;
Instrucción a2;
}
else
{
if (Condición 2)
{
Instrucción b1;
5
Instrucción b2;
}
else
{
Instrucción c1;
Instrucción c2;
}
}
De este modo se pueden introducir tantas condiciones como se quiera dentro de la

condición principal. Una variante de este sistema es utilizando la sentencia elseif, que
permite en una sola línea introducir una condición adicional:
if (Condición 1)
{
Instrucción a1;
Instrucción a2;
}
elseif (Condición 2)
{
Instrucción b1;
Instrucción b2;
}
else
{
Instrucción c1;
Instrucción c2;
}
Para las condiciones tener en cuenta que disponemos de los siguientes operadores:
• == para ver si una variable es igual a otra.

• != distinto.
• >= mayor o igual.
• > mayor.
• <= menor o igual
• < menor
La mejor forma de entender esta estructura condicional es por medio de ejemplos. El

primero que nos plantearemos es generar un valor aleatorio (es decir lo elige la máquina al
azar, como extraer una bolilla de una tómbola de lotería) comprendido entre 1 y 10. Luego
mostraremos un mensaje si es menor o igual a 5 o si es mayor a 5.
El programa completo es:
6
pagina1.php
<html>
<head>
</head>
<body>
<?php
$valor = rand(1, 10);
echo "El valor sorteado es $valor<br>";
if ($valor <= 5) {
echo "Es menor o igual a 5";
} else {
echo "Es mayor a 5";
}
?>
</body>
</html>
Es importante recordar que siempre la condición del if debe ir entre paréntesis. Si la

condición del if se verifica verdadera (es decir el número sorteado es menor o igual a 5)
ejecuta el primer bloque que se encuentra entre llaves. En caso de verificarse falsa la
condición del if se ejecuta el bloque entre llaves que se encuentra después del else.
Ciclos
Las estructuras repetitivas son similares al lenguaje C, JavaScript, Java etc.
El Ciclo for
for([Inicialización de la variable];[Condición];[Incremento o decremento de la variable])

{
[Instrucciones];
}
El primer ejemplo que haremos es mostrar en la página los números del 1 al 100:
7
CicloFor.php
<html>
<head>
</head>
<body>
<?php
for ($f = 1; $f <= 100; $f++) {
echo $f;
echo "<br>";
}
?>
</body>
</html>
El primer argumento del for es la inicialización de una variable, en este caso se inicializa la
variable $f con el valor 1. Este primer argumento del for se ejecuta solo una vez. Luego se
ejecuta el segundo argumento que es la condición. Si la misma se verifica como verdadera
se ejecuta todo el bloque comprendido entre las llaves de apertura y cerrado. Luego de
haberse ejecutado el bloque repetitivo se ejecuta el tercer argumento del for que es el
incremento de la variable, en este caso $f++ incrementa el contenido de la variable $f en 1
(también podemos poner en lugar de $f++ la asignación $f=$f+1)
Luego del incremento de la variable se ejecuta nuevamente la condición del for (segundo
argumento), de validarse nuevamente verdadero pasa a ejecutar el bloque repetitivo.
Este ciclo se repite hasta que la condición del for se verifica falsa.
Ciclo while
La segunda estructura repetitiva es:
while (condición)
{
[Instrucciones];
}
Esta estructura está en casi todos los lenguajes. El bloque se repite mientras la condición
del while sea verdadera.
8
La condición del while se verifica antes de ingresar al bloque a repetir. Si la misma se

verifica falsa la primera vez no se ejecutará el bloque.
Veamos un ejemplo: Generar un valor aleatorio entre 1 y 100, luego imprimir en la página
desde 1 hasta el valor generado (de uno en uno):
cicloWhile.php
<html>
<head>
</head>
<body>
<?php
$valor = rand(1, 100);
$inicio = 1;
while ($inicio <= $valor) {
echo $inicio;
echo "<br>";
$inicio++;
}
?>
</body>
</html>
La variable $inicio tiene el valor 1 antes de ingresar al while. Cada vez que se ejecuta una
vez el bloque del while se incrementa $inicio en uno. Cuando $inicio supere la variable
$valor finalizará la estructura repetitiva y pasará a ejecutarse la instrucción inmediatamente
siguiente a la llave de cerrado del while.
Es importante notar que luego de la condición del while NO se coloca PUNTO y COMA.
El ciclo do/while
Por último tenemos en el lenguaje una estructura repetitiva similar al while llamada
do/while, donde la condición se verifica luego de ejecutarse el bloque repetitivo.
9
do
{
[Instrucciones];
} while (condición);
Ejercicio 3
Mostrar la tabla de multiplicar del 2. Emplear el for, luego el while y por último el
do/while.
La estructura for permite incrementar una variable de 2 en 2:
for ($f = 2; $f <= 20; $f = $f + 2)
Envío de datos de un FORMULARIO hacia variables PHP :controles text

y submit
Una actividad fundamental en PHP es la recolección de datos de un formulario HTML.

El proceso para el manejo de FORMULARIOS requiere generalmente dos páginas, una que
implementa el formulario y otra que procesa los datos cargados en el formulario.
La estructura mínima de un formulario es la siguiente: para la entrada de un nombre de

persona, un objeto text y un botón para el envío del dato al servidor:
EjemploConForm.html
<html>
<head>
<title>Formulario de entrada del dato</title>
</head>
<body>
<form method="post" action="pagina2.php">
Ingrese su nombre:
<input type="text" name="nombre">
<br>
10
<input type="submit" value="confirmar">

</form>
</body>
</html>
Esta página está completamente codificada en HTML, es decir no hay un script en PHP, el
formulario contiene elementos HTML puros.
El elemento <form> y </form> nos permite definir un formulario en la página.

Este elemento tiene dos propiedades que debemos inicializar obligatoriamente: action y
method.
La propiedad action indica el nombre del archivo que recibirá los datos ingresados por el
operador en el formulario y que serán enviados al servidor cuando se presione el botón
(submit). La propiedad method indica como se organizan esos datos para enviarlos al
servidor, pudiendo ser mediante los métodos post o get (normalmente los datos de un
formulario se envían mediante el método post).
Para crear un cuadro de texto para el ingreso del nombre debemos definir un objeto de tipo
"text" y darle un nombre:
La propiedad type nos permite definir el tipo de control y con la propiedad name indicamos
el nombre del control.
Por último todo formulario tiene un botón de tipo submit:
También utilizamos el elemento input pero en la propiedad type indicamos que se trata de
un botón de envío de datos. En la propiedad value indicamos el texto que queremos que
aparezca en el botón.
Ahora necesitamos una página con un pequeño programa en PHP que procese los datos
ingresados en el formulario:
pagina2.php
<html>
<head>
<title>Captura de datos del form</title>
</head>
11
<body>
<?php
echo "El nombre ingresado es:";
echo $_REQUEST['nombre'];
?>
</body>
</html>
Para acceder al dato en PHP se cuenta con un vector llamado $_REQUEST indicando como
subíndice el nombre del cuadro de texto que definimos en el formulario (dicho nombre es
sensible a mayúsculas y minúsculas).
Es común indicar entre comillas simples el subíndice en lugar de comillas dobles (con
comillas dobles también funciona)
En nuestro problema sólo mostramos por pantalla el valor ingresado en el formulario

HTML:
echo $_REQUEST['nombre'];
Ejercicio 4
Confeccionar un formulario que solicite el nombre de una persona y su edad, luego mostrar
si es mayor o menor de edad.
El control radio
El control HTML radio generalmente se utiliza en conjunto con otros controles radio.
Cuando agrupamos un conjunto de controles radio solo uno de ellos puede estar
seleccionado y si seleccionamos otro se desmarca el actual.
Para analizar este control dispondremos un ejemplo:
Implementar un formulario que solicite la carga de dos enteros, uno en cada text.
Disponer dos controles de tipo radio que nos permitan seleccionar si queremos sumar o
restar los dos valores ingresados:
12
FormconBotonesdeRadio.html
<html>
<head>
</head>
<body>
<form action="pagina2.php" method="post">
Ingrese primer valor:
<input type="text" name="valor1">
<br>
Ingrese segundo valor:
<br>
<input type="radio" name="radio1" value="suma">sumar
<br>
<input type="radio" name="radio1" value="resta">restar
<br>
<input type="submit" name="operar">
</form>
</body>
</html>
Es importante notar que se trata nuevamente de un archivo HTML puro, que no tiene
código PHP.
La entrada de los dos números se efectúa en dos controles

Es importante notar que cada text tiene un name DIFERENTE.
Para seleccionar el tipo de operación a efectuar disponemos dos controles de tipo radio:
<input type="radio" name="radio1" value="suma">sumar

<input type="radio" name="radio1" value="resta">restar
Ahora vemos que los dos controles de tipo radio tienen el MISMO nombre. Esto es
necesario para que el navegador sepa que los dos controles están relacionados (recordar que
cuando uno selecciona un radio se debe deseleccionar el otro)
13
Desde la otra página accederemos al value del control seleccionado.
Por último disponemos un control de tipo submit para el envío de los datos del formulario.
El código de la página que procesa el formulario, llamada:"pagina2.php" (la que indicamos
en el elemento FORM del formulario) es:
pagina2.php
<html>
<head>
</head>
<body>
<?php
if ($_REQUEST['radio1'] == "suma") {
$suma = $_REQUEST['valor1'] + $_REQUEST['valor2'];
echo "La suma es:" . $suma;
} else {
if ($_REQUEST['radio1'] == "resta") {
$resta = $_REQUEST['valor1'] - $_REQUEST['valor2'];
echo "La resta es:" . $resta;
}
}
?>
</body>
</html>
El vector asociativo $_REQUEST tiene tres componentes:
$_REQUEST['radio1']
$_REQUEST['valor1']
$_REQUEST['valor2']
En la componente $_REQUEST['radio1'] almacena la cadena "suma" o "resta" según cual

se seleccionó en el formulario.
Con dos if verificamos cual operación está seleccionada y procedemos a efectuarla:
if ($_REQUEST['radio1'] == "suma") {
14

} else {
if ($_REQUEST['radio1'] == "resta") {
}
}
Ejercicio 5
Solicitar que se ingrese por teclado el nombre de una persona y disponer tres controles de
tipo radio que nos permitan seleccionar si la persona: 1-no tiene estudios, 2-estudios
primarios y 3-estudios secundarios.
En la página que procesa el formulario mostrar el nombre de la persona y un mensaje

indicando el tipo de estudios que posee.
El control CheckBox
El control checkbox tiene dos estados: seleccionado o no seleccionado.

Para analizar este control utilizaremos prácticamente el mismo ejemplo que con el objeto
radio:
Implementar un formulario que solicite la carga de dos enteros, uno en cada text.
Disponer dos controles de tipo checkbox que nos permitan seleccionar si queremos sumar
y/o restar los valores ingresados.
El formulario html tiene el siguiente código:
EjemploCheckBox.html
<head>
</head>
<body>
<br>
<br>
<input type="checkbox" name="check1">sumar
15
<br>
<input type="checkbox" name="check2">restar
<br>
</form>
</body>
</html>
Lo nuevo en este problema son los dos controles de tipo checkbox:
<input type="checkbox" name="check1">sumar

<br>
<input type="checkbox" name="check2">restar
<br>
Es importante notar que cada checkbox tiene un nombre distinto.

Ahora veamos el código de la página que procesa el formulario:
pagina2.php
<html>
<head>
</head>
<body>
<?php
if (isset($_REQUEST['check1'])) {
echo "La suma es:" . $suma . "<br>";
}
if (isset($_REQUEST['check2'])) {
}
?>
</body>
</html>
Si el checkbox no está seleccionado en el formulario no se crea una entrada en el vector

asociativo $_REQUEST, para saber si existe una determinada componente en un vector se
16
emplea la función isset, si retorna true significa que existe y por lo tanto el checkbox está
seleccionado.
Disponemos dos if independientes altura ya que los dos controles de tipo checkbox podrían
estar seleccionados.
Ejercicio 6
Hacer un formulario que solicite el nombre de una persona y que permita seleccionar una
serie de deportes que practica (futbol, basket, tennis, voley).
Mostrar en la página que procesa el formulario la cantidad de deportes que practica.
El control select
Veamos ahora como podemos rescatar desde PHP el elemento seleccionado de un control
HTML de tipo select.
Ejemplo:
Implementar un formulario que solicite la carga de dos enteros, uno en cada "text".
Disponer un control de tipo select que nos permita seleccionar si queremos sumar o restar
los dos valores ingresados:
EjemploSelect1.html
<html>
<head>
</head>
<body>
<form action="procesamiento.php" method="post">
<br>
<br>
<select name="operacion">
<option value="suma">sumar</option>
17
<option value="resta">restar</option>
</select>
<br>
</form>
</body>
</html>
Lo nuevo que aparece en este formulario es el control de tipo select.
<select name="operacion">
<option value="suma">sumar</option>
<option value="resta">restar</option>
</select>
Cada opción tiene un valor (value). El seleccionado es el que se enviará a la página que
procesa el formulario. El texto que aparece dentro del control es el que disponemos entre
las marcas option.
Ahora la página que captura los datos ingresados en el formulario es:
procesamiento.php
<html>
<head>
</head>
<body>
<?php
if ($_REQUEST['operacion'] == "suma") {
} else {
if ($_REQUEST['operacion'] == "resta") {
}
}
?>
</body>
</html>
18
El vector asociativo $_REQUEST almacena en la componente del control select el valor de

la opción seleccionada.
Con una serie de if verificamos el valor seleccionado:
if ($_REQUEST['operacion'] == "suma") {
} else {
if ($_REQUEST['operacion'] == "resta") {
}
}
Sólo se puede seleccionar un elemento de un control select (más adelante veremos como
seleccionar varios elementos en forma simultáneo)
Ejercicio 7
Confeccionar un formulario que solicite el ingreso del nombre de una persona y un control
select (en este último permitir la selección de los ingresos mensuales de la persona: 1-
1000,1001-3000,>3000)
En la página que procesa el formulario mostrar un mensaje si debe pagar impuestos, el cual
lo pagan los que ganen más de Q3000.00
El control textarea
El control HTML "textarea" se diferencia del "text" en que permite el ingreso de muchas
líneas.
Ejemplo:
Implementar un formulario web para ingresar el nombre de una persona en un control text y
mediante un control de tipo textarea se permita el ingreso del curriculum de dicha persona.
FormconTextArea.html
<html>
<head>
19
</head>
<body>
Ingrese nombre:<input type="text" name="nombre"><br>
Ingrese su curriculum:<br>
<textarea name="curriculum"></textarea>
<br>
<input type="submit" value="Confirmar">
</form>
</body>
</html>
La sintaxis de este control es bastante diferente a la del control text:
<textarea name="curriculum"></textarea>
Si queremos que aparezca inicializado con texto debemos disponerlo en:
<textarea name="curriculum">Hola Mundo</textarea>
La página PHP que procesa los dos datos ingresados en el formulario es:
pagina2.php
<html>
<head>
</head>
<body>
<?php
echo "El nombre ingresado:" . $_REQUEST['nombre'];
echo "<br>";
echo "El curriculum:" . $_REQUEST['curriculum'];
?>
</body>
</html>
El dato ingresado en el textarea se rescata en forma idéntica que los controles text, es decir
mediante el vector asociativo $_REQUEST:
20
echo "El curriculum:" . $_REQUEST['curriculum'];
Ejercicio 8
Confeccionar una página que muestre un contrato dentro de un textarea, disponer puntos
suspensivos donde el operador debe ingresar un texto. La página que procesa el formulario
sólo debe mostrar el contrato con las modificaciones que hizo el operador.
Ej. de un contrato puede ser:
En la ciudad de [........], se acuerda entre la Empresa [..........]

representada por el Sr. [..............] en su carácter de Apoderado,
con domicilio en la calle [..............] y el Sr. [..............],
futuro empleado con domicilio en [..............], celebrar el presente
contrato a Plazo Fijo, de acuerdo a la normativa vigente de los
artículos 90,92,93,94, 95 y concordantes de la Ley de Contrato de Trabajo N° 20.744.
Arreglos unidimensionales
Un Array es una colección de valores. Los array pueden ser unidimensionales (vectores),
bidimensionales (matrices) y multidimensionales (más de dos dimensiones)
Los arrays se utilizan ampliamente en el lenguaje PHP.
Se utiliza el delimitador [] para acceder a los diferentes elementos del vector.

Se lo puede crear al vuelo, sin tener que declararlo:
$dias[0]=31;
$dias[1]=28;
Luego de estas dos líneas, tenemos creado un vector de dos elementos, a los cuales
accedemos por un subíndice.
echo $dias[0]; //31

echo $dias[1]; //28
El vector, como podemos ver, puede ir creciendo en forma dinámica, es decir que si ahora
hacemos:
$dias[2]=31;
el vector ahora pasa a tener 3 componentes.
21
También podemos obviar el subíndice cuando asignamos los valores:
$dias[]=31;
$dias[]=28;
$dias[]=31;
Automáticamente comienza a numerarse desde cero.

Si necesitamos conocer el tamaño del vector en cualquier momento podemos llamar a la
función count.
echo count($dias); //3
Ejemplo:
Queremos imprimir todos los de un arreglo elementos
pagina1.php
<html>
<head>
</head>
<body>
<?php
$nombres[] = "juan";
$nombres[] = "pedro";
$nombres[] = "ana";
for ($f = 0; $f < count($nombres); $f++) {
echo $nombres[$f];
echo "<br>";
}
?>
</body>
</html>
La función sizeof(<nombre del vector>) es equivalente a count
22
Inicialización de vectores
Otra forma de inicializar un vector es definirlo e inicializarlo simultáneamente:
$edades=array("menores","jovenes","adultos");
Estamos definiendo el vector edades con tres componentes, numeradas automáticamente de

cero a dos.
El ciclo foreach
Cuando tenemos que recorrer en forma completa un vector en PHP es muy común utilizar
la estructura 'foreach'. Veamos el mismo ejemplo anterior para recorrer el vector
$nombres:
pagina1.php
<html>
<head>
</head>
<body>
<?php
$nombres[] = "juan";
$nombres[] = "pedro";
$nombres[] = "ana";
foreach ($nombres as $nombre) {
echo $nombre;
echo "<br>";
}
?>
</body>
</html>
En cada repetición del 'foreach' la variable $nombre almacena una componente del vector
$nombres, luego dentro del 'foreach' mostramos el contenido de la variable $nombre:
foreach ($nombres as $nombre) {

echo $nombre;
23
echo "<br>";
}
Ejercicio 9
Definir un vector con los nombres de los días de la semana. Luego imprimir el primero y el
último elemento del vector.
Archivos de texto
Una actividad fundamental es poder registrar información en el servidor (no como hemos
estado haciendo hasta el momento generando sólo una página con los datos cargados)
Para el registro de datos en el servidor disponemos de dos herramientas que se
complementan en muchos casos (archivos de texto y bases de datos)
En este apartado veremos como crear un archivo de texto y añadir datos al mismo.
Lo presentaremos al tema resolviendo un problema.
Ejemplo:
Implementación de un libro de visitas.

Para resolver este problema plantearemos dos páginas, un formulario para realizar la carga
del nombre del visitante y sus comentarios (disponemos un objeto de tipo "text" y otro de
tipo "textarea"):
pagina1.html
<html>
<head>
</head>
<body>
Ingrese su nombre:
<br>
Comentarios:
<br>
<textarea name="comentarios" rows="10" cols="40"></textarea>
<br>
<input type="submit" value="Registrar">
</form>
24
</body>
</html>
Este formulario es similar a los planteados en problemas anteriores, sólo le hemos agregado
al control textarea, las propiedades rows y cols que dimensionan el mismo en la pantalla:
<textarea name="comentarios" rows="10" cols="40"></textarea>
Veamos ahora la página (pagina2.php) que graba los datos cargados en el formulario en un
archivo:
pagina2.php
<html>
<head>
</head>
<body>
<?php
$ar = fopen("datos.txt", "a") or
die("Problemas en la creacion");
fputs($ar, $_REQUEST['nombre']);
fputs($ar, "\n");
fputs($ar, $_REQUEST['comentarios']);
fputs($ar, "\n");
fputs($ar,"-------------------------------------------------
-------");
fputs($ar, "\n");
fclose($ar);
echo "Los datos se cargaron correctamente.";
?>
</body>
</html>
En primer lugar creamos o abrimos el archivo de texto "datos.txt". El segundo parámetro de

la función fopen indica la forma de apertura de archivo "a" (lo crea o si ya existe el archivo
lo abre para añadir datos al final), "w" (crea el archivo de texto, si existe borra su
contenido) y la última forma de apertura del archivo es "r" (abre el archivo para su lectura)
Como en este problema nos interesa que el archivo vaya creciendo con los datos que
aportan los visitantes al sitio lo abrimos para añadir, parámetro "a".
25
La función fopen retorna una referencia al archivo y la almacenamos en una variable

llamada $ar.
Si el archivo no se puede abrir, se ejecuta la instrucción que se encuentra luego del

operador "or" en nuestro caso llamamos a la función die que finaliza la ejecución del
programa PHP mostrando como mensaje el texto que le pasamos a dicha función (por
ejemplo si el disco duro del servidor está lleno no se podrá crear el archivo de texto)
$ar = fopen("datos.txt", "a") or

die("Problemas en la creacion");
Para la grabación de datos utilizamos la función fputs que tiene dos parámetros: la
referencia al archivo donde grabamos y el string a grabar.
fputs($ar, $_REQUEST['nombre']);
fputs($ar, "\n");
Para el salto de línea en el archivo de texto, usamos los caracteres \n.De esta forma cuando
leamos el archivo de texto lo haremos línea a línea.
Cuando dejamos de trabajar con el archivo llamamos a la función fclose.
Hay que tener muy presente que el archivo se almacena en el servidor y no en la máguina
de la persona que está navegando. Si nos dirigimos a la carpeta c:\xampp\htdocs
encontraremos el archivo "datos.txt", tenga en cuenta que está en la máquina donde se
ejecutó el script de PHP (normalmente en un servidor web). Luego veremos como leer el
contenido del archivo y mostrarlo en otra página del sitio (En nuestro caso como utilizamos
el equipo como cliente/servidor el archivo datos.txt se crea en la misma carpeta donde se
alojan nuestras páginas php).
Ejercicio 10
Hacer un programa en PHP que permita hacer el pedido de pizzas via internet.
El formulario debe ser:
Nombre:[..............]
Direccion:[...................]
Jamon y queso:[x]
Cantidad[...]
Napolitana:[x]
Cantidad[...]
26
Mozzarella:[x]
Cantidad[...]
[Confirmar]
Para el ingreso del nombre, dirección y cantidad de pizzas de cada tipo disponer objetos de
la clase "text".
Disponer tres objetos de tipo "checkbox" para seleccionar los tipos de pizzas.
Por último disponer un botón para el envío de datos: "submit".
Grabar en un archivo de texto llamado "pedidos.txt" cada pedido, separados por una línea
de puntos entre cada pedido.
Lectura de un archivo de texto
Para la lectura de un archivo de texto contamos con la función fgets. Además debemos
abrir el archivo para lectura.
La apertura para leer:
$ar=fopen("datos.txt","r") or
die("No se pudo abrir el archivo");
Para leer:
$linea=fgets($ar);
Ejemplo:
Veamos como mostrar por pantalla el contenido del archivo "datos.txt" creado en el punto
anterior:
pagina1.php
<html>
<head>
</head>
<body>
<?php
$ar = fopen("datos.txt", "r") or
27

while (!feof($ar)) {
$linea = fgets($ar);
$lineasalto = nl2br($linea);
echo $lineasalto;
}
fclose($ar);
?>
</body>
</html>
Lo primero que debemos identificar es la forma de apertura del archivo:
$ar = fopen("datos.txt", "r") or

El segundo parámetro de fopen es "r" es decir read (apertura para lectura), si el archivo no
existe por ejemplo se ejecuta la función die que finaliza el programa mostrando el string
correspondiente.
La función feof retorna true si se ha llegado al final del archivo en caso contrario retorna
false. Para que se impriman todas las líneas del archivo se plantea una estructura repetitiva
que se ejecuta mientras no se llegue al final de archivo (el operador lógico not en PHP es el
caracter !):
while (!feof($ar)) {
Dentro de la estructura repetitiva leemos una línea completa del archivo de texto con la
función fgets:
$linea = fgets($ar);
La variable $linea contiene una línea completa del archivo de texto, inclusive el salto de
línea (\n)
Como el navegador no hace un salto de línea con este carácter, debemos convertir dicho
caracter al elemento <br> propia de HTML. La función que realiza esta actividad se llama
nl2br (new line to br)
El resultado se almacena en una nueva variable que es la que realmente imprimimos:
28
$lineasalto = nl2br($linea);
echo $lineasalto;
Ejercicio 11
Realizar un programa que muestre el archivo de pedido de pizzas via internet del punto
anterior.
Recordemos que creamos el archivo de texto llamado pedidos.txt (grabar la página php en
el mismo directorio donde se encuentra el archivo pedidos.txt)
Vectores asociativos
Este tipo de vectores no es común a otros lenguajes, pero en PHP son de uso indispensable
en distintas situaciones (ya lo empleamos cuando recuperamos información de un
formulario accediendo al vector $_REQUEST que crea PHP en forma automática, cuando
accedamos a datos de una base de datos también lo emplearemos etc.)
Un vector asociativo permite acceder a un elemento del vector por medio de un subíndice
de tipo string.
Inicialmente uno piensa que esto nos complica las cosas, como veremos más adelante la
realidad nos demuestra lo contrario.
Ejemplo:
consideremos que deseamos guardar en un vector el DPI, nombre y dirección de una
persona. Empleando un vector con subíndice entero la solución sería:
<?php
$registro[] = "204563220101";
$registro[] = "Marco Antonio del Cid";
$registro[] = "zona 6";
?>
De esta forma debemos recordar que cuando deseamos mostrar el nombre de la persona
debemos acceder al subíndice 1. Esto es sencillo si tenemos un vector con tres elementos,
pero que sucede si debemos almacenar 20 datos relacionados en un vector.
Un vector asociativo se define de la siguiente forma:
29
<?php
$registro['dni'] = "204563220101";
$registro['nombre'] = "Marco Antonio del Cid";
$registro['direccion'] = "zona 6";
echo $registro['nombre'];
?>
Ahora vemos que para imprimir el nombre de la persona no debemos recordar una posición
dentro de un vector sino un nombre de clave. Esto se hace indispensable cuando
administramos un conjunto de datos grandes.
En un vector asociativo toda componente está asociada a una clave.
Otras formas de crear un vector asociativo:
<?php
$registro = array(
'dpi' => '204563220101',
'nombre' => 'Marco Antonio del Cid',
'direccion' => 'zona 6'
);
echo $registro['dpi'];
?>
Observación:
Cuando tenemos que recorrer en forma completa un vector asociativo en PHP podemos
utilizar la estructura 'foreach'. Veamos un ejemplo:
pagina1.php
<html>
<head>
</head>
<body>
<?php
$articulo = array(
'codigo' => 1,
'descripcion' => 'manzanas',
'precio' => 30.25
);
30
foreach ($articulo as $clave => $valor) {

echo 'Para la clave :' . $clave . " almacena el valor:
" . $valor;
echo "<br>";
}
?>
</body>
</html>
En cada repetición del 'foreach' la variable $clave almacena el subíndice del vector y la
variable $valor contiene el valor de la componente del vector:
foreach ($articulo as $clave => $valor) {

echo 'Para la clave :' . $clave . " almacena el valor:
" . $valor;
echo "<br>";
}
Luego se muestra al ejecutar la aplicación:
• Para la clave :codigo almacena el valor: 1

• Para la clave :descripcion almacena el valor: manzanas
• Para la clave :precio almacena el valor: 30.25
Podemos recorrer el vector asociativo $_REQUEST mediante un foreach e imprimir tanto

la clave como el valor.
Ejemplo:
Desarrollaremos una aplicación que solicite la carga de 5 números en un formulario HTML

y al presionar un botón se calcule la suma en el servidor.
pagina1.html
<head>
</head>
<body>
<br>
31

<br>
Ingrese tercer valor:
<br>
Ingrese cuarto valor:
<br>
Ingrese quinto valor:
<br>
<input type="submit">
</form>
</body>
</html>
Es importante notar que al input de tipo 'submit' no le definimos la propiedad 'name', con el
objetivo que no se cargue en el vector asociativo '$_REQUEST'.
Ahora la página que suma todos los valores ingresados es:
pagina2.php
<html>
<head>
</head>
<body>
<?php
$suma = 0;
foreach ($_REQUEST as $clave => $valor) {
echo "Valor: " . $valor;
echo "<br>";
$suma = $suma + $valor;
}
echo "La suma es: " . $suma;
?>
</body>
</html>
32
Como vemos podemos recorrer en forma completa los 5 elementos del vector
'$_REQUEST' y acceder tanto a su valor como su clave:
$suma = 0;
foreach ($_REQUEST as $clave => $valor) {
echo "<br>";
}
Si solo queremos acceder a los valores del vector asociativo y no a sus claves, luego
podemos codificar la sintaxis del foreach:
foreach ($_REQUEST as $valor) {

echo "<br>";
}
Ejercicio 12
Crear un vector asociativo que almacene las claves de acceso de 5 usuarios de un sistema.
Acceder a cada componente por su nombre. Imprimir una componente del vector.
Funciones en PHP
La sintaxis para la definición de una función en PHP es:
function [nombre de la función]([parámetros])

{
[algoritmo]
}
Ejemplo:
Implementaremos una función que muestre un titulo centrado en patalla, y la llamaremos

posteriormente dos veces:
33
EjemploFunciones.php
<html>
<head>
</head>
<body>
<?php Aplicamos algo de

function mostrartitulo($mensaje)
{ CSS
echo "<h1 style=\"text-align:center\">";
echo $mensaje;
echo "</h1>";
}
mostrartitulo("Primer titulo");
echo "<br>";
mostrartitulo("Segundo segundo");
?>
</body>
</html>
Para mostrar el titulo centrado utilizamos el elemento h1 de HTML y definimos un estilo

centrado para el mismo.
Si vemos la función, notamos que lo más trabajoso es definir todos los elementos HTML
para crear el titulo. Es importante notar que en PHP para introducir las dobles comillas
dentro de un string debemos anteceder el carácter '\'; para introducir el carácter '\' debemos
escribir dos barras \\.
Las llamadas a la función las hacemos por medio de su nombre y pasamos el único
parámetro que requiere:
mostrartitulo("Primer titulo");
echo "<br>";
mostrartitulo("Segundo segundo");
Las funciones nos permiten tener un programa más ordenado y facilitan la reutilización del
código.
Más adelante veremos como hacer archivos con rutinas comunes a muchas páginas.
34
Una función puede retornar un dato, supongamos que necesitamos una función que nos
retorne el promedio de dos valores, el código sería:
Ejemplo:
EjemploFunciones2.php
<html>
<head>
</head>
<body>
<?php
function retornarpromedio($valor1, $valor2)
{
$pro = $valor1 / $valor2;
return $pro;
}
$v1 = 100;
$v2 = 50;
$p = retornarpromedio($v1, $v2);
echo $p;
?>
</body>
</html>
Cuando una función retorna un dato debemos emplear la palabra clave return seguida del
valor que devuelve.
En la llamada a la función el valor retornado se almacena generalmente en una variable:
$p = retornarpromedio($v1, $v2);
Si queremos que retorne más de un dato debemos emplear parámetros por referencia.
Supongamos que necesitamos ahora que una función nos retorne el cuadrado y cubo de un
número:
35
Ejemplo:
EjemploFunciones3.php
<html>
<head>
</head>
<body>
<?php
function cuadradocubo($valor, &$cuad, &$cub)
{
$cuad = $valor * $valor;
$cub = $valor * $valor * $valor;
}
cuadradocubo(2, $c1, $c2);

echo "El cuadrado de 2 es:" . $c1 . "<br>";
echo "El cubo de 2 es:" . $c2;
?>
</body>
</html>
Es decir, cuando le antecedemos el carácter ampersand al parámetro, es por referencia.

El objetivo es asignarle cierto valor al parámetro y posteriormente el dato quedará
almacenado en la variable que le pasamos a la función.
function cuadradocubo($valor, &$cuad, &$cub)

{
$cuad = $valor * $valor;
$cub = $valor * $valor * $valor;
}
El parámetro $cuad se almacena en la variable $c1 y el parámetro $cub se almacena en $c2.

Es la forma más adecuada de modificar variables dentro de una función.
Ejercicio 13
Hacer un formulario que solicite el nombre de usuario y su clave en dos oportunidades. En

la página que se procesan los datos del formulario implementar una función que imprima
un mensaje si las dos claves ingresadas son distintas.
36
Conexión con bases de datos MySQL
Uno de los empleos principales de PHP es el acceso a una base de datos en el servidor. Las
operaciones básicas se hacen empleando como lenguaje el SQL.
PHP implementa distintas funciones según la base de datos a emplear. Existen funciones
actualmente para acceder a las siguientes servidores de bases de datos:
• MySQL
• MariaDB
• Microsoft SQL Server
• Oracle
• PostgreSQL
• SysBase
• FrontBase
• Informix
• InterBase
• Ingres
• mSQL
• dBase
• SQLlite
El más empleado en la actualidad en la web es el gestor de base de datos MySQL.

Cuando instaló el entorno de XAMPP en un principio para trabajar con PHP, se instaló el
MySQL o MariaDB.
Para crear una base de datos el XAMPP instala también un programa codificado en PHP
que nos permite interactuar con el MySQL o MariaDB.
Ejemplo:
• Crear una base de datos llamada: base1

• Crear una tabla denominada: alumnos, con la siguiente estructura:
codigo int auto_increment primary key

nombre varchar(50)
mail varchar(70)
codigocurso int
El código del alumno es de tipo numérico (int) y al indicar que es auto_increment se

generará automáticamente por el gestor de base de datos.
37
Los campos nombre y mail son de tipo varchar (podemos almacenar cualquier caracter) y
por último el campo codigocurso representa el curso a tomar por el alumno (1=PHP, 2=ASP
y 3=JSP)
El campo clave de esta tabla es el código de alumno (es decir no podemos tener dos
alumnos con el mismo código, no así el nombre del alumno que puede eventualmente
repetirse)
Insertar registros (Alta de registros en una tabla)
Luego de crear una base de datos y sus tablas (Vamos a trabajar con la base de datos ya
creada: base1, que contiene la tabla alumnos), veremos como agregar registros.
Para añadir datos en la tabla empleamos el comando SQL llamado insert.
Necesitamos dos páginas para este proceso, una será el formulario de carga de datos y la
siguiente será la que efectúe la inserción en la tabla.
Formulario de carga de datos:
pagina1.html
<html>
<head>
</head>
<body>
<h1>Alta de Alumnos</h1>
Ingrese nombre:
<input type="text" name="nombre"><br>
Ingrese mail:
<input type="text" name="mail"><br>
Seleccione el curso:
<select name="codigocurso">
<option value="1">PHP</option>
<option value="2">ASP</option>
<option value="3">JSP</option>
</select>
<br>
<input type="submit" value="Registrar">
</form>
</body>
</html>
38
El formulario es bastante similar a los que venimos desarrollando en puntos anteriores, tal
vez lo distinto es cómo emplearemos el control "select" del curso a desarrollar:
<option value="1">PHP</option>
<option value="2">ASP</option>
<option value="3">JSP</option>
</select>
Cada opción tiene su respectivo valor (en este caso los números 1,2 y 3) y los textos a
mostrar PHP, ASP y JSP. El dato que se envía a la otra página es el código de curso (esto
debido a que definimos la propiedad value).
Ahora veremos como realizar la registración de los datos cargados en el formulario, en la

tabla alumnos de la base de datos base1:
pagina2.php
<html>
<html>
<head>
</head>
<body>
<?php
$conexion = mysqli_connect("localhost", "root", "",
"base1") or
die("Problemas con la conexión");
mysqli_query($conexion, "insert into

alumnos(nombre,mail,codigocurso) values
('$_REQUEST[nombre]','$_REQUEST[mail]',
$_REQUEST[codigocurso])")
or die("Problemas en el select" .
mysqli_error($conexion));
mysqli_close($conexion);
echo "El alumno fue dado de alta.";

?>
</body>
39
</html>
Veamos los pasos para efectuar el alta en la tabla alumnos:
$conexion = mysqli_connect("localhost", "root", "", "base1")

or
La función mysqli_connect se conecta a una base de datos de tipo MySql, el primer

parámetro es la dirección donde se encuentra el gestor de base de datos (en este caso en el
mismo servidor por lo que indicamos esto con "localhost"), el segundo parámetro es el
nombre de usuario de la base de datos ("root" en nuestro caso, que es el usuario por defecto
que crea MySql para el administrador), seguidamente indicamos la clave del usuario root
(por defecto al instalar el XAMPP se crea con clave vacía) y por último indicamos el
nombre de la base de datos a conectarnos (en nuestro ejemplo ya creamos la base de datos
llamada: base1 que tiene la tabla alumnos)
En caso de haber algún error en la llamada a la función la misma retorna false por lo que se
ejecuta la instrucción seguida del operador or, en nuestro caso llamamos a la función die
que detiene la ejecución del programa y muestra el mensaje por pantalla.
El paso más importante es la codificación del comando SQL insert(debemos llamar a la

función mysqli_query pasando como primer parámetro la referencia a la conexion y el
segundo parámetro es un string con el comando insert):
mysqli_query($conexion, "insert into

alumnos(nombre,mail,codigocurso) values
('$_REQUEST[nombre]','$_REQUEST[mail]',
$_REQUEST[codigocurso])")
or die("Problemas en el select" .
La sintaxis del comando insert es bastante sencilla, indicamos el nombre de la tabla y los
campos de la tabla a cargar. Luego debemos indicar en el mismo orden los valores a cargar
en cada campo (dichos valores los rescatamos del formulario anterior).
Los campos de tipo varchar SQL requiere que encerremos entre comillas simples, esto
sucede para el nombre y el mail; en cambio, para el codigocurso esto no debe ser así.
Otra cosa a tener en cuenta es que los subíndices de los vectores asociativos no deben ir
entre simples comillas ya que se encuentran dentro de un string, sino se producirá un error.
40
En caso que MySql detecte un error, retorna false la función mysqli_query, por lo que se
ejecuta la instrucción posterior al or, es decir la función die que mostrará el error generado
por MySql llamando a la función mysqli_error.
Por último cerramos la conexión con la base de datos y mostramos un mensaje indicando
que la carga se efectuó en forma correcta.
Ejercicio 14
Crear en la base de datos "base1" otra tabla llamada "cursos".

La estructura de esta segunda tabla debe ser:
codigo int auto_increment primery_key

nombrecurso varchar(40)
Implementar las dos páginas necesarias para efectuar el alta de cursos. Un formulario para
ingresar el nombre del curso
Lectura de registros desde una base de datos
Para recuperar datos desde MySQL o MariaDB debemos emplear el comando select:
select codigo,nombre,mail,codigocurso from alumnos.
Debemos pasar desde PHP un string con este comando para que MySQL lo ejecute y
retorne todas las filas de la tabla alumnos.
Veremos entonces como recuperar los datos almacenados en la tabla alumnos de la base de
datos "base1".
El programa que muestra los registros en una página es:
pagina1.php
<html>
<head>
</head>
<body>
41
<?php
"base1") or
$registros = mysqli_query($conexion, "select

codigo,nombre,mail,codigocurso
from alumnos") or
die("Problemas en el select:" . mysqli_error($conexion));
while ($reg = mysqli_fetch_array($registros)) {

echo "Codigo:" . $reg['codigo'] . "<br>";
echo "Nombre:" . $reg['nombre'] . "<br>";
echo "Mail:" . $reg['mail'] . "<br>";
echo "Curso:";
switch ($reg['codigocurso']) {
case 1:
echo "PHP";
break;
case 2:
echo "ASP";
break;
case 3:
echo "JSP";
break;
}
echo "<br>";
echo "<hr>";
} //fin de while
?>
</body>
</html>
La primer parte es similar a lo visto hasta ahora, es decir nos conectamos con el servidor de
base de datos y seleccionamos la base de datos base1:
$conexion = mysqli_connect("localhost", "root", "", "base1")

or
42
El comando SQL que nos permite recuperar datos de tablas se llama SELECT. Indicamos
los campos a rescatar de la tabla y luego de la palabra clave from indicamos el nombre de la
tabla:

codigo,nombre,mail,codigocurso
from alumnos") or
En caso de haber codificado incorrectamente, el comando SQL select la función

mysqli_query retorna false, por lo que se ejecuta el comando siguiente al operador or, es
decir la función die.
Si el comando SQL es correcto, en la variable $registros se almacena una referencia a los

datos rescatados de la tabla alumnos. Ahora debemos ir mostrando registro a registro los
datos extraídos:
Para rescatar registro a registro los datos obtenidos por el select debemos llamar a la
función mysqli_fetch_array. Esta función retorna un vector asociativo con los datos del
registro rescatado, o false en caso de no haber más registros. Es decir que si retorna un
registro se almacena en el vector $reg y la condición del while se valida como verdadero y
pasa a ejecutarse el bloque del while:

echo "Curso:";
case 1:
echo "PHP";
break;
case 2:
echo "ASP";
break;
case 3:
echo "JSP";
break;
}
echo "<br>";
echo "<hr>";
}
43
El bloque del while muestra el contenido del registro rescatado por la función
mysqli_fetch_array. Como vemos, para rescatar cada campo accedemos mediante el vector
asociativo $reg indicando como subíndice un campo contenido en el select:$reg['codigo']
Cada vez que llamamos a la función mysqli_fetch_array nos retorna el siguiente registro.
Cuando debemos mostrar el curso mediante la instrucción switch, analizamos si tiene un
1,2 ó 3 y procedemos a mostrar el nombre del curso.
Para separar cada alumno en la página HTML disponemos el elemento "<hr>"
Ejercicio 15
Hacer un programa que recupere los datos de la tabla cursos de la base de datos base1.
Mostrar el código de curso y su nombre.
Consultas
El proceso de consulta de datos de una tabla es similar al de listado, la diferencia es que se

muestra sólo aquel o aquellos que cumplen la condición por la que buscamos.
Haremos un programa que nos permita consultar los datos de un alumno ingresando su mail
para su búsqueda. Tengamos en cuenta que no puede haber dos alumnos con el mismo mail,
por lo que la consulta nos puede arrojar uno o ningún registro.
Debemos codificar un formulario para el ingreso del mail a consultar:
pagina1.html
<html>
<head>
</head>
<body>
Ingrese el mail del alumno a consultar:
<input type="text" name="mail">
<br>
<input type="submit" value="buscar">
</form>
44
</body>
</html>
Por otro lado tenemos el archivo "pagina2.php" que se encarga de buscar el mail ingresado
en el formulario:
pagina2.php
<html>
<head>
</head>
<body>
<?php
"base1") or

codigo,nombre,codigocurso
from alumnos where
mail='$_REQUEST[mail]'") or
if ($reg = mysqli_fetch_array($registros)) {
echo "Curso:";
case 1:
echo "PHP";
break;
case 2:
echo "ASP";
break;
case 3:
echo "JSP";
break;
}
} else {
echo "No existe un alumno con ese mail.";
}
?>
</body>
45
</html>
Lo más importante se encuentra en el comando select:

codigo,nombre,codigocurso
from alumnos where
Acá es donde con la clausula where seleccionamos sólo el registro que cumple con la
condición que el mail sea igual al que ingresamos.
Como sólo puede haber un registro que cumpla la condición, llamamos a la función
mysqli_fetch_array en un if y no una estructura repetitiva como el listado:
En caso de retornar un vector asociativo la condición del if se verifica como verdadera y

pasa a mostrar los datos, en caso de retornar false se ejecuta el else.
Ejercicio 16
Crear un programa que permita ingresar el nombre de un alumno en un formulario, luego

mostrar los datos del mismo (tener en cuenta que puede haber más de un alumno con el
mismo nombre)
Eliminar registros
El objetivo de este punto es el borrado de un registro de una tabla. Para ello,

implementaremos un algoritmo que solicite ingresar el mail de un alumno y posteriormente
efectúe su borrado.
Para eliminar filas en una tabla debemos utilizar el comando SQL delete.
La primera página es idéntica a la consulta, ya que debemos implementar un formulario que
solicite la carga del mail del alumno:
46
pagina1.html
<html>
<head>
</head>
<body>
Ingrese el mail del alumno a borrar:
<input type="text" name="mail">
<br>
<input type="submit" value="buscar y borrar">
</form>
</body>
</html>
Por otro lado tenemos el archivo "pagina2.php" que se encarga de buscar el mail ingresado
en el formulario y en caso que exista se procede a borrarlo:
pagina2.php
<html>
<head>
</head>
<body>
<?php
"base1") or die("Problemas con la conexión");
$registros = mysqli_query($conexion, "select codigo from

alumnos where mail='$_REQUEST[mail]'") or
mysqli_query($conexion, "delete from alumnos where
die("Problemas en el select:" .
echo "Se efectuó el borrado del alumno con dicho mail.";

} else {
47
echo "No existe un alumno con ese mail.";

}
?>
</body>
</html>
En esta segunda página efectuamos dos llamadas a la función mysqli_query, una para
consultar si existe el mail ingresado y otra para efectuar el borrado del registro respectivo.
Si no existe el mail ingresado mostramos un mensaje de tal situación.
Ejercicio 17
Hacer un programa que permita ingresar el nombre de un curso por teclado y

posteriormente efectúe el borrado de dicho registro en la tabla cursos. Mostrar un mensaje
si no existe el curso.
Eliminación de todos los registros de una tabla
Vimos en el concepto anterior que podemos borrar una o más filas de una tabla indicando
en el where del comando SQL delete la condición que debe cumplir la fila para ser borrada.
Para borrar todos los registros de una tabla debemos llamar al comando delete de SQL sin
disponer la cláusula where.
Ejemplo:
Es importante tener en cuenta que la ausencia de la cláusula where en el comando delete

eliminará todas las filas de la tabla.
pagina1.php
<html>
<head>
</head>
<body>
48
<?php
mysqli_query($conexion, "delete from alumnos") or

echo "Se efectuó el borrado de todos los alumnos.";
?>
</body>
</html>
Actualización de registros con Update
De las actividades con una tabla esta es la más larga. Vamos a resolverlo implementando
tres páginas, la primera un formulario de consulta del mail de un alumno, la segunda otro
formulario que nos permita cargar su mail modificado y la última registrará el cambio en la
tabla.
El formulario de consulta del mail del alumno es similar a problemas anteriores:
pagina1.html
<html>
<head>
</head>
<body>
Ingrese el mail del alumno:
</form>
</body>
</html>
49
La segunda página es la más interesante y con conceptos nuevos:
pagina2.php
<html>
<head>
</head>
<body>
<?php

"base1") or
$registros = mysqli_query($conexion, "select * from alumnos

where mail='$_REQUEST[mail]'") or
?>

Ingrese nuevo mail:
<input type="text" name="mailnuevo" value="<?php echo
$reg['mail'] ?>">
<br>
<input type="hidden" name="mailviejo" value="<?php echo
$reg['mail'] ?>">
<input type="submit" value="Modificar">
</form>
<?php
} else
echo "No existe alumno con dicho mail";
?>
</body>
</html>
Lo primero que podemos observar es que si el if se verifica verdadero se ejecuta un bloque

que contiene código HTML:
?>
50

Ingrese nuevo mail:
<input type="text" name="mailnuevo" value="<?php echo
$reg['mail'] ?>">
<br>
$reg['mail'] ?>">
</form>
<?php
Es decir que podemos disponer bloques de PHP dispersos dentro de la página.

Otro concepto importante es como enviar el mail del primer formulario a la tercer página,
esto se logra con los controles de tipo "hidden", este tipo de control no se visualiza en el
formulario pero se envía al presionar el botón submit.
Si queremos que el control text se cargue con el mail ingresado en el formulario anterior
debemos cargar la propiedad value con dicho valor:

$reg['mail'] ?>">
Por último la pagina3.php es la que efectúa la modificación de la tabla propiamente dicha.

Con el mail ingresado en la pagina1.php, el mail modificado en la pagina2.php se efectúa el
update.
pagina3.php
<html>
<head>
</head>
<body>
<?php
mysqli_query($conexion, "update alumnos

set mail='$_REQUEST[mailnuevo]'
where mail='$_REQUEST[mailviejo]'")
or die("Problemas en el select:" .
echo "El mail fue modificado con éxito";
?>
</body>
51
</html>
Tengamos en cuenta que el segundo formulario nos envía dos datos:
$_REQUEST[mailnuevo] y $_REQUEST[mailviejo].
Si no llamamos a:
Cuando finaliza la ejecución del script de PHP se libera automáticamente la conexión con
MySQL.
Ejercicio 18
Efectuar la modificación del nombre del curso de la tabla "cursos". Para la búsqueda
ingresar el código de curso.
Consultas con varias tablas
Ahora veremos como imprimir todos los alumnos inscriptos a los cursos junto al nombre
del curso donde está inscripto. Los datos se encuentran en las tablas "alumnos" y "cursos".
Debemos aparear el código de curso de la tabla "alumnos" con el código de la tabla
"cursos".
El código del programa que hace esto es el siguiente:
pagina1.php
<html>
<head>
</head>
<body>
<?php
52

"base1") or
$registros = mysqli_query($conexion, "select alu.codigo as

codigo, nombre, mail, codigocurso, nombrecurso
from alumnos as alu inner join cursos as cur on
cur.codigo=alu.codigocurso") or

echo "Curso:" . $reg['nombrecurso'] . "<br>";
echo "<hr>";
}
?>
</body>
</html>
Hay varias cosas nuevas cuya sintaxis necesitamos analizar, la primera es como hacer el
apareo con la tabla cursos:
inner join cursos as cur on cur.codigo=alu.codigocurso

Luego de las palabras claves inner join, indicamos la tabla que necesitamos aparear,
podemos crear un alias de una tabla mediante la palabra clave as. En el resto de la consulta,
en vez de indicar el nombre de la tabla, hacemos referencia al alias(generalmente un
nombre más corto).
Seguidamente de la palabra clave on, indicamos los campos por los que apareamos las
tablas, en nuestro caso el codigo de la tabla cursos con el codigocurso de la tabla alumnos.
Otro punto a tener en cuenta es indicar en el select que campos debemos rescatar de las
tablas, es decir, indicarle a que tabla pertenece en el caso que tengan el mismo nombre:

codigo, nombre,mail,codigocurso,nombrecurso
cur.codigo=alu.codigocurso") or
En este caso rescatamos el código del alumno (y no el código de curso). Debemos crear un
alias si dos tablas tienen el mismo nombre de campo para evitar confusión; como ocurre
aquí con el campo codigo de las tablas alumnos y cursos. También creamos un alias para la
tabla alumnos.
53
Cuando rescatamos los datos y los mostramos en la página, hacemos referencia al alias del
campo:

echo "<hr>";
}
Ejercicio 19
Confeccionar un programa que permita ingresar el código de un alumno y nos muestre su

nombre, mail y nombre del curso en el cual está inscripto. Hacer un formulario donde se
ingrese el código de alumno y otra página donde se muestren los datos respectivos. Mostrar
un mensaje si no existe el código de alumno ingresado.
Función count
Hay en MySQL funciones que nos permiten contar registros, calcular sumas, promedios,
obtener valores máximos y mínimos. Veamos la función count.
Cuando necesitamos saber la cantidad de registros utilizamos la función count, por ejemplo
si deseamos conocer la cantidad de alumnos que hay en la tabla "alumnos" debemos
implementar el siguiente comando SQL:
select count(*) as cantidad from alumnos
Implementamos una página que muestra este resultado:
pagina1.php
<html>
<head>
</head>
<body>
<?php
54
$registros = mysqli_query($conexion, "select count(*) as

cantidad from alumnos") or die("Problemas en el select:" .
$reg = mysqli_fetch_array($registros);
echo "La cantidad de alumnos inscriptos son :" .

$reg['cantidad'];
?>
</body>
</html>
En la sentencia select en vez de indicar los campos de la tabla, colocamos la llamada a la

función count pasando como parámetro un asterisco y creando un alias para su posterior
recuperación e impresión del dato:
El select no tiene cláusula where ya que debemos contar todos los alumnos y no los de
algún curso en particular.
La llamada a la función mysqli_fetch_array se hace sin estructura condicional o repetitiva

ya que sabemos que nos retornará un único registro (en realidad, un registro que tiene una
sola columna llamada cantidad, en caso de estar vacía la tabla alumnos, se almacena cero
en el alias cantidad):
$reg = mysqli_fetch_array($registros);
Ejercicio 20
Hacer un programa que muestre por pantalla los nombres de todos los cursos y al final la
cantidad total de cursos.
Actualización de dos tablas
Ahora complicaremos un poco la modificación de un registro consultando dos tablas.

Supongamos que un alumno desea cambiarse de curso, es decir, se inscribió en uno y quiere
borrarse de ese e inscribirse en otro diferente. Debemos mostrar en un "select" el curso
actual en el que está inscripto y los otros cursos disponibles en la tabla "cursos".
55
Para resolver este problema tenemos que plantear tres páginas, una donde ingresemos el
mail del alumno, la segunda donde se pueda cambiar el curso y por última una que permita
modificar la tabla "alumnos" con el nuevo curso seleccionado.
La primer página de ingreso del mail es:
pagina1.html
<html>
<head>
</head>
<body>
Ingrese el mail del alumno:
</form>
</body>
</html>
La segunda página y la más importante en cuanto a novedades es la siguiente:
pagina2.php
<html>
<head>
</head>
<body>
<?php
"base1") or

if ($regalu = mysqli_fetch_array($registros)) {
?>

$regalu['mail'] ?>">
56
<?php
$registros = mysqli_query($conexion, "select * from
cursos") or die("Problemas en el select:" .

if ($regalu['codigocurso'] == $reg['codigo'])
echo "<option value=\"$reg[codigo]\"
selected>$reg[nombrecurso]</option>";
else
echo "<option
value=\"$reg[codigo]\">$reg[nombrecurso]</option>";
}
?>
</select>
<br>
</form>
<?php
} else
echo "No existe alumno con dicho mail";
?>
</body>
</html>
La primera consulta de la tabla alumnos es para verificar si existe un alumno con el mail
ingresado por teclado:

if ($regalu = mysqli_fetch_array($registros)) {
En caso de existir un alumno con dicho mail, el if se verifica verdadero y pasamos a poblar
el control select con los distintos cursos que contiene la tabla "cursos":
$registros = mysqli_query($conexion, "select * from cursos")

or die("Problemas en el select:" . mysqli_error($conexion));

if ($regalu['codigocurso'] == $reg['codigo'])
57
{
echo "<option value=\"$reg[codigo]\"
selected>$reg[nombrecurso]</option>";
}
else
echo "<option value=\"$reg[codigo]\">$reg[nombrecurso]</
option>";
}
?>
</select>
Para que aparezca seleccionado el curso actual debemos inicializar lo marca option con la
propiedad selected. Es decir que el if dentro del while se verifica verdadero una solo vez.
Por último la tercer página procede a registrar el cambio en la tabla "alumnos":
pagina3.php
<html>
<head>
</head>
<body>
<?php
$registros = mysqli_query($conexion, "update alumnos

set codigocurso=$_REQUEST[codigocurso]
where mail='$_REQUEST[mailviejo]'") or
die("Problemas en el select:" .
echo "El curso fue modificado con exito";
?>
</body>
</html>
Ejercicio 21
Confeccionar la modificación del mail, nombre y curso de la tabla "alumnos". Ingresar por
teclado el código de alumno para su búsqueda.
Solución
58
Agrupamientos
Entre las muchas posibilidades que nos brinda SQL, una es agrupar registros y obtener
información resumida de tablas.
En nuestro problema, un listado interesante sería mostrar la cantidad de alumnos inscriptos

por curso. Para resolver de una manera sencilla esta situación, SQL nos permite agrupar los
registros de la tabla "alumnos" por la columna "codigocurso" y contar la cantidad de
registros que hay por cada código de curso igual.
El programa que nos permite resolver este problema es el siguiente:
pagina1.php
<html>
<head>
</head>
<body>
<?php
"base1") or

count(alu.codigo) as cantidad, nombrecurso
cur.codigo=alu.codigocurso group by alu.codigocurso") or

echo "Nombre del curso:" . $reg['nombrecurso'] . "<br>";
echo "Cantidad de inscriptos:" . $reg['cantidad'] .

"<br>";
echo "<hr>";
59
}
?>
</body>
</html>
Hay varias partes importantes en este código; primero, en el select indicamos que cuente la
cantidad de registros de la tabla "alumnos":
select count(alu.codigo) as cantidad,

nombrecurso from alumnos as alu
Pero, como veremos más adelante, en 'cantidad' no se almacena la cantidad total de

registros de la tabla "alumnos" debido a que más adelante empleamos la cláusula group by.
Como necesitamos rescatar el nombre del curso hacemos el apareo con la tabla "cursos":
inner join cursos as cur on cur.codigo=alu.codigocurso
Por último en la sentencia select de SQL disponemos la cláusula group by:
group by alu.codigocurso
Con esta cláusula se hace un corte de control por cada grupo de registros que tienen el
mismo código de curso almacenado.
Luego mostramos el nombre de curso con la cantidad de inscriptos para dicho curso:

echo "Nombre del curso:" . $reg['nombrecurso'] . "<br>";
echo "Cantidad de inscriptos:" . $reg['cantidad'] .
"<br>";
echo "<hr>";
}
Ejercicio 22
Hacer un programa que muestre el nombre del curso, la cantidad de inscriptos y todos los
inscriptos a dicho curso. Repetir esto con todos los cursos.
Es decir, en la página debe aparecer algo parecido a:
60
Nombre del curso:PHP

Cantidad de inscriptos:3
Nombres: Marco del Cid - Rodriguez Pablo - Gonzalez Ana
Nombre del curso:JSP

Cantidad de inscriptos:2
Nombres: Hernández Héctor - Roca Marta
Solución
Parámetros en un hipervínculo
Hasta ahora hemos visto como enviar datos de una página a otra mediante formularios. Otra
forma muy utilizada que complementa la anterior es como parámetro en un hipervínculo.
Confeccionaremos una página que muestre tres hipervínculos, cada uno tiene por objetivo
mostrar en una página las tablas de multiplicar del 2, del 3 o la del 5.
La primer página es un archivo HTML puro, ya que sólo disponemos las marcas de
hipervínculos:
pagina1.html
<html>
<head>
</head>
<body>
<A href="pagina2.php?tabla=2">Tabla del 2</A> <br>
<A href="pagina2.php?tabla=5">Tabla del 5</A>
</body>
</html>
La sintaxis para pasar parámetros en un hipervínculo es:
Es decir, luego del caracter "?" indicacamos el nombre del parámetro y seguidamente el
valor del mismo.
La página que rescata el valor pasado como parámetro es la siguiente:
61
pagina2.php
<html>
<head>
</head>
<body>
<?php
echo "Listado de la tabla del $_REQUEST[tabla] <br>";
for ($f = 1; $f <= 10; $f++) {
$valor = $f * $_REQUEST['tabla'];
echo $valor . "-";
}
?>
</body>
</html>
Es decir que con el mismo vector asociativo $_REQUEST recuperamos los datos enviados
por parámetro en la llamada a la página.
Observaciones:
PHP crea 2 vectores asociativos llamados $_GET y $_POST. El primero almacena los datos
pasados en el hipervínculo, quiere decir que el problema anterior lo podemos resolver con
la siguiente sintaxis:
pagina2.php
<html>
<head>
</head>
<body>
<?php
echo "Listado de la tabla del $_GET[tabla] <br>";
for ($f = 1; $f <= 10; $f++) {
$valor = $f * $_GET['tabla'];
echo $valor . "-";
}
?>
</body>
</html>
62
El vector asociativo $_POST almacena los datos que se pasan por medio de un formulario
HTML.
El vector asociativo $_REQUEST almacena tanto los datos del vector $_GET como el
$_POST.
Ejercicio 23
Confeccionar un programa que muestre una página con todos los nombres de la tabla
"cursos". Los nombres deben aparecer como hipervínculos a otra página que deberá
mostrar todos los alumnos inscriptos a dicho curso. Como parámetro en el hipervínculo,
pasar el código de curso.
Paginación de registros.
En situaciones en las cuales una consulta retorna muy muchos datos, en vez de enviarlos
todos al navegador, se puede enviar un conjunto limitado de registros. Luego, mediante
hipervínculos, ver el resto de datos. Por ejemplo, cuando hacemos búsquedas con el
servidor google, generalmente no nos retorna todas las direcciones donde se encuentran los
resultados buscados, nos retorna páginas con 10 enlaces por página (pensemos el tiempo de
transferencia si nos retornara 1.000.000 de enlaces).
Bueno, ahora resolvamos con el lenguaje PHP este problema de paginación, mostraremos
dos alumnos por página:
pagina1.php
<?php
if (isset($_REQUEST['pos']))
$inicio = $_REQUEST['pos'];
else
$inicio = 0;
?>
<html>
<head>
</head>
<body>
<?php
"base1") or
63

codigo, nombre, mail, codigocurso, nombrecurso from alumnos
as alu inner join cursos as cur on cur.codigo=alu.codigocurso
limit $inicio,2") or die("Problemas en el select:" .
ysqli_error($conexion));
$impresos = 0;

$impresos++;
echo "<hr>";
}
if ($inicio == 0)
echo "anteriores ";
else {
$anterior = $inicio - 2;
echo "<a href=\"pagina1.php?pos=$anterior\">Anteriores </
a>";
}
if ($impresos == 2) {
$proximo = $inicio + 2;
echo "<a
href=\"pagina1.php?pos=$proximo\">Siguientes</a>";
} else
echo "siguientes";
?>
</body>
</html>
La función isset retorna verdadero si existe la variable que le pasamos como parámetro, en
este caso le estamos pasando la componente pos del vector asociativo $_REQUEST.
Cuando llamamos por primera vez a esta página, lo hacemos : pagina1.php sin parámetros,
por lo que el if se verifica como falso. Es decir la variable $inicio se carga con el valor 0.
Otro concepto importante es la cláusula limit que es propia del gestor MySQL. Mediante
esta cláusula limitamos la cantidad de registros que retorna el select. El primer valor del
limit indica a partir de cual registro y el segundo la cantidad de registros. Es decir si un
select sin limit retorna 100 registro, luego utilizando por ejemplo la sintaxis limit 50,25 nos
retornará, de esa lista de 100 registros, a partir del registro de la posición 50, 25 registros.
En nuestro problema indicamos que retorne desde valor que tenga la variable $inicio y
como cantidad 2 (páginas con 2 registros):
64
$registros=mysqli_query($conexion,"select alu.codigo as
codigo, nombre, mail,codigocurso, nombrecurso
cur.codigo=alu.codigocurso
limit $inicio,2") or
die("Problemas en el select:".mysqli_error($conexion));
Seguidamente mostramos todos los registros retornados y
además los contamos:
$impresos = 0;
$impresos++;
echo "<hr>";
}
Ahora vemos dónde dispondremos los hipervínculos, hacia adelante o atrás:
if ($inicio == 0)
echo "anteriores ";
else {
$anterior = $inicio - 2;
echo "<a href=\"pagina1.php?pos=$anterior\">Anteriores </
a>";
}
Si la variable $inicio vale 0 significa que no hay registros antes de éste, por lo que sólo
mostramos un texto "anteriores". En caso que la variable $inicio sea distinta de 0, se ejecuta
el else, donde disponemos un hipervínculo con la misma página e inicializando el
parámetro pos con el valor de $inicio menos 2.
Si el contador $impresos tiene el valor 2 significa que posiblemente hay más registros por
mostrar y debemos disponer un hipervínculo con la misma página pero inicializando el
parámetro pos con el valor de $inicio más 2:
if ($impresos == 2) {
$proximo = $inicio + 2;
echo "<a
href=\"pagina1.php?pos=$proximo\">Siguientes</a>";
} else
echo "siguientes";
65
Ejercicio 24
Confeccionar un programa que muestre los registros de la tabla "cursos" con páginas de 3
registros.
Subir un archivo al servidor (Upload)
Una actividad común en un sitio es poder almacenar un archivo en el servidor, más

comúnmente conocido como upload.
Se necesita en muchas ocasiones este algoritmo, por ejemplo para subir fotos, documentos,
programas, etc.
Se requieren dos páginas, una de ellas, un formulario donde seleccionamos el archivo a
enviar y otra página donde se graba el archivo en el servidor.
El formulario para hacer la selección del archivo es:
pagina1.html
<html>
<head>
</head>
<body>
<form action="pagina2.php" method="post"
enctype="multipart/form-data">
Seleccione el archivo:
<input type="file" name="foto"><br>
<input type="submit" value="Enviar">
</form>
</body>
</html>
Veamos los puntos que tenemos que respetar cuando efectuamos el upload de archivos:
<form action="pagina2.php" method="post" enctype="multipart/form-data">
Se define una nueva propiedad para la etiqueta form, con esta indicamos que dentro del
formulario de carga se envían archivos. Hay que tener mucho cuidado cuando tipeamos esta
propiedad, si nos equivocamos en algún carácter el proceso de upload no funcionará.
El control HTML para la selección del archivo se llama "file":
<input type="file" name="foto"><br>
66
Automáticamente aparecerá el botón dentro de la página para poder navegar en nuestro

disco duro para la selección del archivo (por defecto PHP está configurado para poder
cargar archivos de hasta 2 Mb, de todos modos, a este valor lo podemos modificar).
La segunda página es:
pagina2.php
<html>
<head>
</head>
<body>
<?php
copy($_FILES['foto']['tmp_name'], $_FILES['foto']['name']);
echo "La foto se registro en el servidor.<br>";
$nom = $_FILES['foto']['name'];
echo "<img src=\"$nom\">";
?>
</body>
</html>
Cuando se ejecuta esta página, ya está almacenado en el servidor el archivo, en una carpeta
temporal. Ahora nos hace falta copiar el mismo a la carpeta donde se encuentra nuestra
página (en definitiva nuestro sitio de internet). Para esto llamamos a la función copy:
copy($_FILES['foto']['tmp_name'],$_FILES['foto']['name']);
La matriz $_FILES almacena el nombre del archivo guardado en el directorio temporal

($_FILES['foto']['tmp_name']) y el nombre del archivo originario ($_FILES['foto']['name'])
Por último mostramos en la página el archivo de la imagen que se almacenó en el servidor:
$nom=$_FILES['foto']['name'];
echo "<img src=\"$nom\">";
Otras cosas interesantes que tiene la matriz $_FILES:
$_FILES['foto']['name'] El nombre original del fichero en

la máquina cliente.
$_FILES['foto']['type'] El tipo de archivo (si el navegador
lo proporciona). Un ejemplo podría ser "image/gif".
$_FILES['foto']['size'] El tamaño en bytes del fichero recibido.
$_FILES['foto']['tmp_name'] El nombre del archivo temporal que se
67
utiliza para almacenar en el servidor el archivo recibido.
Ejercicio 25
Confeccionar un programa que permita hacer múltiples upload con una página (por ejemplo
que permita seleccionar hasta 3 archivos)
Creación y lectura de una cookie
El protocolo HTTP es desconectado. Esto significa que cada vez que solicitamos una
página a un servidor representa una conexión distinta.
Una cookie es una pequeña cantidad de datos almacenada por el navegador del usuario
cuando solicita una página a un servidor. El que envía que se genere la cookie es el
servidor.
Una cookie consta de un nombre, un valor, una fecha de expiración y un servidor. Una
cookie está limitada a 4KB.
Luego que una cookie es creada sólo el sitio que la creó puede leerla. Luego de creada una
cookie, cada vez que el navegador del usuario visita el sitio, se envía dicha cookie. Otra
cosa importante que hay que tener en cuenta es que el usuario del browser puede configurar
el mismo para no permitir la creación de cookies, lo que significa que el uso de cookies
debe hacerse con moderación y cuando la situación lo requiera. De todos modos, el 99% de
los navegadores están configurados para permitir la creación de cookies.
Para la creación de una cookie desde PHP debemos llamar a la función setcookie.
Los parámetros de esta función son:
setcookie( <nombre de la cookie>, <valor de la cookie>, <fecha de expiración>, <carpeta

del servidor>)
Con un problema sencillo entenderemos el uso de esta función. Supongamos que queremos
que los usuarios que entran a nuestro sitio puedan configurar con qué color de fondo de
página quiere que aparezca cada vez que ingresa al sitio. Al color seleccionado por el
visitante lo almacenaremos en una cookie. En caso que no exista el color, por defecto es
blanco.
La primera página mostrará un formulario con tres controles de tipo radio para la selección
del color. También esta página verificará si existe la cookie creada, en caso afirmativo fijará
68
el fondo de la página con el valor de la cookie. Tengamos en cuenta que la primera vez que
ejecutemos este programa la página es de color blanco, luego variará según el color
seleccionado en el formulario.
El código de la primera página es:
pagina1.php
<html>
<head>
</head>
<body <?php if (isset($_COOKIE['color'])) echo "

style=\"background:$_COOKIE[color]\"" ?>>
Seleccione de que color desea que sea la página de ahora
en más:<br>
<input type="radio" value="rojo" name="radio">Rojo<br>
<input type="radio" value="verde" name="radio">Verde<br>
<input type="radio" value="azul" name="radio">Azul<br>
<input type="submit" value="Crear cookie">
</form>
</body>
</html>
El formulario no varía en nada respecto a otros vistos. Lo más importante es el bloque PHP
que verifica si ya existe la cookie en el navegador del cliente. Es importante entender que la
primera vez que ejecutemos esta página la cookie no existe, por lo que el if se verifica
falso:
<body <?php if (isset($_COOKIE['color'])) echo " style=\"background:

$_COOKIE[color]\"" ?>>
El vector asociativo $_COOKIE almacena todas las cookies creadas por el visitante. Si es
la primera vez que peticionamos esta página, el vector $_COOKIE no tendrá elementos.
Es decir que la marca body no tiene inicializada la propiedad style.
La segunda página es la que crea la cookie propiamente dicha:
69
pagina2.php
<?php
if ($_REQUEST['radio'] == "rojo")
setcookie("color", "#ff0000", time() + 60 * 60 * 24 * 365,
"/");
elseif ($_REQUEST['radio'] == "verde")
setcookie("color", "#00ff00", time() + 60 * 60 * 24 * 365,
"/");
elseif ($_REQUEST['radio'] == "azul")
setcookie("color", "#0000ff", time() + 60 * 60 * 24 * 365,
"/");
?>
<html>
<head>
</head>
<body>
Se creó la cookie.
<br>
<a href="pagina1.php">Ir a la otra página</a>
</body>
</html>
La llamada a la función setcookie debe hacerse antes de imprimir cualquier etiqueta

HTML, de lo contrario no funcionará.
Como podemos observar, la creación de la cookie se hace llamando a la función setcookie:
<?php
if ($_REQUEST['radio'] == "rojo")
setcookie("color", "#ff0000", time() + 60 * 60 * 24 * 365,
"/");
elseif ($_REQUEST['radio'] == "verde")
setcookie("color", "#00ff00", time() + 60 * 60 * 24 * 365,
"/");
elseif ($_REQUEST['radio'] == "azul")
setcookie("color", "#0000ff", time() + 60 * 60 * 24 * 365,
"/");
?>
El nombre de la cookie se llama "color" y el valor que almacenamos depende de que

control de tipo radio esté seleccionado en la página anterior. La fecha de expiración de la
cookie la calculamos fácilmente llamando a la función time() que nos retorna la fecha
actual en segundos y le sumamos el producto 60*60*24*365 (60 segundos * 60 minutos *
70
24 horas * 365 días) es decir que la cookie existirá en la máquina del visitante hasta el año
próximo.
Cuando indicamos como directorio la sintaxis "/" significa que la cookie se crea a nivel del
sitio y con cuaquier petición a dicho sitio, el navegador enviará la cookie al servidor.
Por último dispusimos en esta página un hipervínculo a la página anterior, para ver que, de
ahora en más, cada vez que ejecutemos la pagina1.php, el color de fondo de la misma
dependerá del valor de la cookie registrada.
Ejercicio 26
Crear un formulario que solicite la carga del nombre de usuario. Cuando se presione un
botón crear una cookie para dicho usuario. Luego cada vez que ingrese al formulario
mostrar el último nombre de usuario ingresado.
71
Eliminar una cookie
Para borrar una cookie se debe llamar a la función setcookie con una fecha anterior a la
actual.
También tengamos en cuenta que una cookie tiene una fecha de expiración por lo que si un
visitante reingresa a nuestro sitio y la cookie expiró el navegador no la enviará.
Haremos un algoritmo muy común a muchos sitios que administran webmail.

Recordaremos en una cookie el mail ingresado por el operador, el código fuente de la
primera página es la siguiente:
pagina1.php
<html>
<head>
</head>
<body>
Ingrese su mail:
<input type="text" name="mailusuario" value="<?php if
(isset($_COOKIE['mail'])) echo $_COOKIE['mail']; ?>">
<br>
<input type="radio" name="opcion" value="recordar">
Recordar en esta computadora el mail ingresado.
<br>
<input type="radio" name="opcion" value="norecordar">
No recordar.
<br>
</form>
</body>
</html>
Es decir, disponemos un control text y como valor de la misma verificamos si el cliente

tiene ya una cookie guardada en su máquina, en caso afirmativo la mostramos dentro del
text modificando la propiedad value.
Mediante dos controles de tipo radio daremos la posibilidad al cliente que el navegador
recuerde o no el mail ingresado.
72
Como es sabido, la primera vez que accedamos a la página no existe la cookie llamada
mail.
La segunda página:
pagina2.php
<?php
if ($_REQUEST['opcion'] == "recordar")
setcookie("mail", $_REQUEST['mailusuario'], time() + (60 *
60 * 24 * 365), "/");
elseif ($_REQUEST['opcion'] == "norecordar")
setcookie("mail", "", time() - 1000, "/");
?>
<html>
<head>
</head>
<body>
<?php
if ($_REQUEST['opcion'] == "recordar")
echo "cookie creada";
elseif ($_REQUEST['opcion'] == "norecordar")
echo "cookie eliminada";
?>
<br>
<a href="pagina1.php">Ir a la otra página</a>
</body>
</html>
En esta página verificamos cuál control radio está seleccionado, si es el primero, creamos la
cookie mail con una vida de 1 año:
setcookie("mail",$_REQUEST['mailusuario'],time()+(60*60*24*365),"/");
En caso que esté seleccionado el segundo radio, creamos la misma cookie pero con una
fecha de caducidad inferior a la actual (con esto estamos virtualmente eliminando la
cookie):
setcookie("mail","",time()-1000,"/");
73
Cookie de sesión
Para crear una cookie que sólo tenga existencia mientras no cerremos la ventana del
navegador, pasaremos como fecha de expiración de la cookie, el valor cero.
Una vez que la instancia del navegador se cierra, dicha cookie desaparecerá.
Este tipo de cookie puede ser muy útil para validar un usuario en un conjunto de páginas, si
previamente ingresó correctamente su nombre de usuario y clave. Es decir, una vez
validado el usuario, se verifica en páginas sucesivas si existe la cookie. Una vez que el
usuario cierra el navegador, no hay posibilidad de solicitar las páginas recorridas sin previa
validación nuevamente de clave y usuario.
Entonces la sintaxis es:
setcookie(<nombre de la cookie>,<valor>,0)
Veamos un pequeño ejemplo para crear y verificar si existe una cookie de sesión.
La primera página es:
pagina1.php
<html>
<head>
</head>
<body>
<?php
if (isset($_COOKIE['usu']))
echo "Cookie de sesión creada. Su valor es
$_COOKIE[usu]";
else
echo "No existe cookie de sesión";
?>
<br>
<a href="pagina2.php">Crear cookie de sesión</a>
</body>
</html>
La segunda página es la que crea la cookie de sesión:
74
pagina2.php
<?php
setcookie("usu", "marco", 0);
?>
<html>
<head>
</head>
<body>
Cookie de sesión creada.<br>
<a href="pagina1.php">Retornar a la página anterior.</a>
</body>
</html>
Si ejecutamos este programa y creamos la cookie de sesión, la misma existirá mientras no

cerremos el navegador. Probemos luego cerrando completamente el navegador y veremos
que contiene la cookie de sesión.
75
76
CAPÍTULO 2
JAVA
77
Programas Secuenciales
Cuando en un problema sólo participan operaciones, entradas y salidas se la denomina una

estructura secuencial.
Los problemas diagramados y codificados previamente emplean solo estructuras
secuenciales.
La programación requiere una práctica ininterrumpida de diagramación y codificación de

problemas.
Ejemplo:
Realizar la carga de dos números enteros por teclado e imprimir su suma y su producto.
Tenemos dos entradas num1 y num2 (recordar cuáles son los nombres de variables
correctas), dos operaciones: realización de la suma y del producto de los valores ingresados
y dos salidas, que son los resultados de la suma y el producto de los valores ingresados. En
el símbolo de impresión podemos indicar una o más salidas, eso queda a criterio del
programador, lo mismo para indicar las entradas por teclado.
Programa:
import java.util.Scanner;
public class SumaProductoNumeros {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int num1,num2,suma,producto;
System.out.print("Ingrese primer valor:");
num1=teclado.nextInt();
System.out.print("Ingrese segundo valor");
suma=num1 + num2;
producto=num1 * num2;
System.out.print("La suma de los dos valores es:");
System.out.println(suma);
System.out.print("El producto de los dos valores es:");
System.out.println(producto);
}
}
Recordemos que tenemos que seguir todos los pasos vistos para la creación de un proyecto,
su clase, definición de la función main y la codificación del diagrama de flujo (como son
problemas muy sencillos con una única clase puede especificar el nombre del proyecto con
el mismo nombre de la clase: SumaProductoNumeros)
78
Algunas cosas nuevas que podemos notar:
Podemos definir varias variables en la misma línea:
int num1,num2,suma,producto;
Si llamamos a la función println en lugar de print, la impresión siguiente se efectuará en la

próxima línea:
Problemas propuestos
1) Realizar la carga del lado de un cuadrado, mostrar por pantalla el perímetro del
mismo (El perímetro de un cuadrado se calcula multiplicando el valor del lado por
cuatro)
2) Escribir un programa en el cual se ingresen cuatro números, calcular e informar la

suma de los dos primeros y el producto del tercero y el cuarto.
3) Realizar un programa que lea cuatro valores numéricos e informar su suma y

promedio.
4) Se debe desarrollar un programa que pida el ingreso del precio de un artículo y la

cantidad que lleva el cliente. Mostrar lo que debe abonar el comprador.
Estructuras de decisión
No todos los problemas pueden resolverse empleando estructuras secuenciales. Cuando hay
que tomar una decisión aparecen las estructuras condicionales.
Por supuesto que en un problema se combinan estructuras secuenciales y condicionales.
Estructura condicional simple
Cuando se presenta la elección tenemos la opción de realizar una actividad o no realizar

ninguna.
Por el camino del verdadero pueden existir varias operaciones, entradas y salidas, inclusive
ya veremos que puede haber otras estructuras condicionales.
79
Ejemplo
Ingresar el sueldo de una persona, si supera los Q3000 mostrar un mensaje en pantalla
indicando que debe abonar impuestos.
Diagrama de flujo:
Programa:
public class EstructuraCondicionalSimple1 {

float sueldo;
System.out.print("Ingrese el sueldo:");
sueldo=teclado.nextFloat();
if (sueldo>3000) {
System.out.println("Esta persona debe abonar
impuestos");
}
}
}
La palabra clave "if" indica que estamos en presencia de una estructura condicional;
seguidamente disponemos la condición entre paréntesis. Por último encerrada entre llaves
las instrucciones de la rama del verdadero.
Es necesario que las instrucciones a ejecutar en caso que la condición sea verdadera estén
encerradas entre llaves { }, con ellas marcamos el comienzo y el fin del bloque del
verdadero.
Estructura condicional de doble alternativa
Cuando se presenta la elección tenemos la opción de realizar una actividad u otra. Es decir
tenemos actividades por el verdadero y por el falso de la condición. Lo más importante que
hay que tener en cuenta que se realizan las actividades de la rama del verdadero o las del
falso, NUNCA se realizan las actividades de las dos ramas.
En una estructura condicional compuesta tenemos entradas, salidas, operaciones, tanto por
la rama del verdadero como por la rama del falso.
80
Ejemplo:
Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el
mayor de ellos.
Programa:
public class EstructuraCondicionalCompuesta1 {

int num1,num2;
System.out.print("Ingrese segundo valor:");
if (num1>num2) {
System.out.print(num1);
} else {
}
}
}
Cotejemos el diagrama de flujo y la codificación y observemos que el primer bloque de

llaves después del if representa la rama del verdadero y el segundo bloque de llaves
representa la rama del falso.
Compilemos el programa, si hubo errores sintácticos corrijamos y carguemos dos valores,

como por ejemplo:
Ingrese el primer valor: 10

Ingrese el segundo valor: 4
10
Si ingresamos los valores 10 y 4 la condición del if retorna verdadero y ejecuta el primer

bloque.
Un programa se controla y corrige probando todos sus posibles resultados.

Ejecutemos nuevamente el programa e ingresemos:
Ingrese el primer valor: 10

Ingrese el segundo valor: 54
54
81
Cuando a un programa le corregimos todos los errores sintácticos y lógicos ha terminado

nuestra tarea y podemos entregar el mismo al USUARIO que nos lo solicitó.
Operadores
En una condición deben disponerse únicamente variables, valores constantes y operadores

relacionales.
Operadores Relacionales
> (mayor)
< (menor)
>= (mayor o igual)
<= (menor o igual)
== (igual)
!= (distinto)
Operadores Aritméticos
+ (más)
- (menos)
* (producto)
/ (división)
% (resto de una división) Ej.: x=13%5; {se guarda 3}
Hay que tener en cuenta que al disponer una condición debemos seleccionar que operador
relacional se adapta a la pregunta.
Ejemplos:
Se ingresa un número multiplicarlo por 10 si es distinto a 0. (!=)

Se ingresan dos números mostrar una advertencia si son iguales. (==)
Los problemas que se pueden presentar son infinitos y la correcta elección del operador
sólo se alcanza con la práctica intensiva en la resolución de problemas.
1) Realizar un programa que lea por teclado dos números, si el primero es mayor al
segundo informar su suma y diferencia, en caso contrario informar el producto y la
división del primero respecto al segundo.
82
2) Se ingresan tres notas de un alumno, si el promedio es mayor o igual a siete mostrar

un mensaje "Promocionado".
3) Se ingresa por teclado un número positivo de uno o dos dígitos (1..99) mostrar un
mensaje indicando si el número tiene uno o dos dígitos.
(Tener en cuenta que condición debe cumplirse para tener dos dígitos, un número entero)
If anidado
Decimos que una estructura condicional es anidada cuando por la rama del verdadero o el
falso de una estructura condicional hay otra estructura condicional.
Ejemplo:
Confeccionar un programa que pida por teclado tres notas de un alumno, calcule el
promedio e imprima alguno de estos mensajes:
• Si el promedio es >=7 mostrar "Promocionado".

• Si el promedio es >=4 y <7 mostrar "Regular".
• Si el promedio es <4 mostrar "Reprobado".
Programa:
public class EstructuraCondicionalAnidada1 {

int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");
nota1=teclado.nextInt();
System.out.print("Ingrese segunda nota:");
System.out.print("Ingrese tercer nota:");
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) {
System.out.print("Promocionado");
} else {
if (promedio>=4) {
System.out.print("Regular");
} else {
System.out.print("Reprobado");
}
83
}
}
}
Codifiquemos y ejecutemos este programa. Al correr el programa deberá solicitar por

teclado la carga de tres notas y mostrarnos un mensaje según el promedio de las mismas.
Podemos definir un conjunto de variables del mismo tipo en una misma línea:
int nota1,nota2,nota3;
Esto no es obligatorio pero a veces, por estar relacionadas, conviene.

A la codificación del if anidado podemos observarla por el else del primer if.
Para no tener problemas (olvidarnos) con las llaves de apertura y cerrado podemos ver la
siguiente regla:
Cada vértice representa una llave de apertura y una de cierre:
llaves en los if en java
1) Se cargan por teclado tres números distintos. Mostrar por pantalla el mayor de ellos.
2) Se ingresa por teclado un valor entero, mostrar una leyenda que indique si el
número es positivo, nulo o negativo.
3) Confeccionar un programa que permita cargar un número entero positivo de hasta

tres cifras y muestre un mensaje indicando si tiene 1, 2, o 3 cifras. Mostrar un
mensaje de error si el número de cifras es mayor.
4) Un postulante a un empleo, realiza un test de capacitación, se obtuvo la siguiente

información: cantidad total de preguntas que se le realizaron y la cantidad de
preguntas que contestó correctamente. Se pide confeccionar un programa que
ingrese los dos datos por teclado e informe el nivel del mismo según el porcentaje
de respuestas correctas que ha obtenido, y sabiendo que:
Nivel máximo: Porcentaje>=90%.

Nivel medio: Porcentaje>=75% y <90%.
Nivel regular: Porcentaje>=50% y <75%.
Fuera de nivel: Porcentaje<50%.
84
Condiciones compuestas con operadores lógicos
Hasta ahora hemos visto los operadores:
relacionales (>, <, >=, <= , ==, !=)

matemáticos (+, -, *, /, %)
pero nos están faltando otros operadores imprescindibles:
lógicos (&&, ||).
Estos dos operadores se emplean fundamentalmente en las estructuras condicionales para

agrupar varias condiciones simples.
Operador &&
Traducido se lo lee como Y. Si la Condición 1 es verdadera Y la condición 2 es verdadera

luego ejecutar la rama del verdadero.
Cuando vinculamos dos o más condiciones con el operador &&, las dos condiciones deben
ser verdaderas para que el resultado de la condición compuesta de Verdadero y continúe por
la rama del verdadero de la estructura condicional.
La utilización de operadores lógicos permiten en muchos casos plantear algoritmos más

cortos y comprensibles.
Ejemplo:
Hacer un programa que lea por teclado tres números distintos y nos muestre el mayor.
Programa:
public class CondicionesCompuestas1 {

int num1,num2,num3;
85
System.out.print("Ingrese tercer valor:");
if (num1>num2 && num1>num3) {
} else {
if (num2>num3) {
}else {
}
}
}
}
Operador ||
Traducido se lo lee como O. Si la condición 1 es Verdadera O la condición 2 es Verdadera,

luego ejecutar la rama del Verdadero.
Cuando vinculamos dos o más condiciones con el operador Or, con que una de las dos
condiciones sea Verdadera alcanza para que el resultado de la condición compuesta sea
Verdadero.
Ejemplo:
Se carga una fecha (día, mes y año) por teclado. Mostrar un mensaje si corresponde al
primer trimestre del año (enero, febrero o marzo) Cargar por teclado el valor numérico del
día, mes y año.
Ejemplo: dia:10 mes:1 año:2010.
Programa:
public class CondicionesCompuestas2 {

int dia,mes,año;
System.out.print("Ingrese nro de día:");
dia=teclado.nextInt();
System.out.print("Ingrese nro de mes:");
mes=teclado.nextInt();
System.out.print("Ingrese nro de año:");
año=teclado.nextInt();
if (mes==1 || mes==2 || mes==3) {
86
System.out.print("Corresponde al primer trimestre");

}
}
}
1) Realizar un programa que pida cargar una fecha cualquiera, luego verificar si dicha
fecha corresponde a Navidad.
2) Se ingresan tres valores por teclado, si todos son iguales se imprime la suma del
primero con el segundo y a este resultado se lo multiplica por el tercero.
3) Se ingresan por teclado tres números, si todos los valores ingresados son menores a
10, imprimir en pantalla la leyenda "Todos los números son menores a diez".
4) Se ingresan por teclado tres números, si al menos uno de los valores ingresados es
menor a 10, imprimir en pantalla la leyenda "Alguno de los números es menor a
diez".
5) Escribir un programa que pida ingresar la coordenada de un punto en el plano, es

decir dos valores enteros x e y (distintos a cero).
Posteriormente imprimir en pantalla en que cuadrante se ubica dicho punto. (1º
Cuadrante si x > 0 Y y > 0 , 2º Cuadrante: x < 0 Y y > 0, etc.)
6) De un operario se conoce su sueldo y los años de antigüedad. Se pide confeccionar

un programa que lea los datos de entrada e informe:
a) Si el sueldo es inferior a 500 y su antigüedad es igual o superior a 10 años, otorgarle

un aumento del 20 %, mostrar el sueldo a pagar.
b)Si el sueldo es inferior a 500 pero su antigüedad es menor a 10 años, otorgarle un
aumento de 5 %.
c) Si el sueldo es mayor o igual a 500 mostrar el sueldo en pantalla sin cambios.
Escribir un programa en el cual: dada una lista de tres valores numéricos distintos se
calcule e informe su rango de variación (debe mostrar el mayor y el menor de ellos)
87
El ciclo while
Hasta ahora hemos empleado estructuras SECUENCIALES y CONDICIONALES. Existe

otro tipo de estructuras tan importantes como las anteriores que son las estructuras
REPETITIVAS.
Una estructura repetitiva permite ejecutar una instrucción o un conjunto de instrucciones

varias veces.
Una ejecución repetitiva de sentencias se caracteriza por:

- La o las sentencias que se repiten.
- El test o prueba de condición antes de cada repetición, que motivará que se repitan o no
las sentencias.
Observación: No debemos confundir la representación gráfica de la estructura repetitiva

while (Mientras) con la estructura condicional if (Si)
Importante: Si la condición siempre retorna verdadero estamos en el caso de un ciclo

repetitivo infinito. Dicha situación es un error de programación, nunca finalizará el
programa.
Ejemplo:
Realizar un programa que imprima en pantalla los números del 1 al 100.
Programa:
public class EstructuraRepetitivaWhile1 {

int x;
x=1;
while (x<=100) {
System.out.print(x);
System.out.print(" - ");
x = x + 1;
}
}
}
Importante:Como podemos observar no hemos creado un objeto de la clase Scanner. Esto

debido a que en este programa no hay que ingresar datos por teclado. Para las salidas
utilizamos la función print, que se encuentra creada por defecto en cualquier programa que
codifiquemos en Java.
88
Recordemos que un problema no estará 100% solucionado si no hacemos el programa en

Java que muestre los resultados buscados.
Probemos algunas modificaciones de este programa y veamos que cambios se deberían

hacer para:
1 - Imprimir los números del 1 al 500.

2 - Imprimir los números del 50 al 100.
3 - Imprimir los números del -50 al 0.
4 - Imprimir los números del 2 al 100 pero de 2 en 2 (2,4,6,8 ....100).
Respuestas:
1 - Debemos cambiar la condición del while con x<=500.

2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condición x<=0.
4 - Inicializar a x con el valor 2 y dentro del bloque repetitivo incrementar a x en 2
( x = x + 2 ).
1) Escribir un programa que solicite ingresar 10 notas de alumnos y nos informe

cuántos tienen notas mayores o iguales a 7 y cuántos menores.
2) Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la altura

promedio de las personas.
3) En una empresa trabajan n empleados cuyos sueldos oscilan entre $100 y $500,
realizar un programa que lea los sueldos que cobra cada empleado e informe
cuántos empleados cobran entre $100 y $300 y cuántos cobran más de $300.
Además el programa deberá informar el importe que gasta la empresa en sueldos al
personal.
4) Realizar un programa que imprima 25 términos de la serie 11 - 22 - 33 - 44, etc. (No

se ingresan valores por teclado)
5) Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 - 16 - 24,
etc.
6) Realizar un programa que permita cargar dos listas de 15 valores cada una. Informar
con un mensaje cual de las dos listas tiene un valor acumulado mayor (mensajes
"Lista 1 mayor", "Lista 2 mayor", "Listas iguales")
89
7) Tener en cuenta que puede haber dos o más estructuras repetitivas en un algoritmo.
8) Desarrollar un programa que permita cargar n números enteros y luego nos informe
cuántos valores fueron pares y cuántos impares.
Emplear el operador % en la condición de la estructura condicional:
if (valor%2==0) //Si el if da verdadero luego es par.
El ciclo for
Cualquier problema que requiera una estructura repetitiva se puede resolver empleando la
estructura while. Pero hay otra estructura repetitiva cuyo planteo es más sencillo en ciertas
situaciones.
En general, la estructura for se usa en aquellas situaciones en las cuales CONOCEMOS la

cantidad de veces que queremos que se ejecute el bloque de instrucciones. Ejemplo: cargar
10 números, ingresar 5 notas de alumnos, etc. Conocemos de antemano la cantidad de
veces que queremos que el bloque se repita. Veremos, sin embargo, que en el lenguaje Java
la estructura for puede usarse en cualquier situación repetitiva, porque en última instancia
no es otra cosa que una estructura while generalizada.
Sintaxis:
for (variable=valorIncial; condición de límite; variable=incremento)

{
cuerpo del ciclo
Ejemplo 1:
Realizar un programa que imprima en pantalla los números del 1 al 100.
90
Programa:
public class EstructuraRepetitivaFor1 {

int f;
for(f=1;f<=100;f++) {
System.out.print(f);
System.out.print("-");
}
}
}
Ejemplo 2:
Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre
posteriormente la suma de los valores ingresados y su promedio. Este problema ya lo
desarrollamos , lo resolveremos empleando la estructura for.
Programa:
public class EstructuraRepetitivaFor2 {

int suma,f,valor,promedio;
suma=0;
for(f=1;f<=10;f++) {
System.out.print("Ingrese valor:");
valor=teclado.nextInt();
suma=suma+valor;
}
System.out.print("La suma es:");
promedio=suma/10;
System.out.print("El promedio es:");
System.out.print(promedio);
}
}
1) Confeccionar un programa que lea n pares de datos, cada par de datos corresponde a
la medida de la base y la altura de un triángulo. El programa deberá informar:
a) De cada triángulo la medida de su base, su altura y su superficie.
91
b) La cantidad de triángulos cuya superficie es mayor a 12.
2) Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al 50)
3) Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos muestre

la tabla de multiplicar del mismo (los primeros 12 términos)
Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9, hasta el 36.

Realizar un programa que lea los lados de n triángulos, e informar:
a) De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados iguales), isósceles
(dos lados iguales), o escaleno (ningún lado igual)
b) Cantidad de triángulos de cada tipo.
c) Tipo de triángulo que posee menor cantidad.
El Ciclo do while
La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una vez su
bloque repetitivo, a diferencia del while o del for que podían no ejecutar el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una
vez se ejecutará el bloque repetitivo.
La condición de la estructura está abajo del bloque a repetir, a diferencia del while o del for
que está en la parte superior.
Sintaxis:
do
{
cuerpo del ciclo
} while (
El bloque de operaciones se repite MIENTRAS que la condición sea Verdadera.

Si la condición retorna Falso el ciclo se detiene. En Java, todos los ciclos repiten por
verdadero y cortan por falso.
Es importante analizar y ver que las operaciones se ejecutan como mínimo una vez.
92
Ejemplo 1:
Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un
mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor
0.
Programa:
public class EstructuraRepetitivaDoWhile1 {

int valor;
do {
System.out.print("Ingrese un valor entre 0 y 999 (0
finaliza):");
if (valor>=100) {
System.out.println("Tiene 3 dígitos.");
}
else {
if (valor>=10) {
System.out.println("Tiene 2 dígitos.");
}
else {
System.out.println("Tiene 1 dígito.");
}
}
} while (valor!=0);
}
}
Ejemplo 2:
Escribir un programa que solicite la carga de números por teclado, obtener su promedio.
Finalizar la carga de valores cuando se cargue el valor 0.
Programa:
public class EstructuraRepetitivaDoWhile2 {

93
int suma,cant,valor,promedio;
suma=0;
cant=0;
do {
System.out.print("Ingrese un valor (0 para
finalizar):");
if (valor!=0) {
suma=suma+valor;
cant++;
}
} while (valor!=0);
if (cant!=0) {
promedio=suma/cant;
System.out.print("El promedio de los valores
ingresados es:");
System.out.print(promedio);
} else {
System.out.print("No se ingresaron valores.");
}
}
}
1. Realizar un programa que acumule (sume) valores ingresados por teclado hasta
ingresar el 9999 (no sumar dicho valor, indica que ha finalizado la carga). Imprimir
el valor acumulado e informar si dicho valor es cero, mayor a cero o menor a cero.
2. En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada

cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos
debe finalizar al ingresar un valor negativo en el número de cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe:
a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo que:
Estado de la cuenta 'Acreedor' si el saldo es >0.

'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
94
Cadenas de caracteres
En Java hemos visto que cuando queremos almacenar un valor entero definimos una
variable de tipo int, si queremos almacenar un valor con decimales definimos una variable
de tipo float. Ahora si queremos almacenar una cadena de caracteres (por ejemplo un
nombre de una persona) debemos definir un objeto de la clase String.
Más adelante veremos en profundidad y detenimiento los conceptos de CLASE y OBJETO,

por ahora solo nos interesa la mecánica para trabajar con cadenas de caracteres.
Ejemplo 1:
Solicitar el ingreso del nombre y edad de dos personas. Mostrar el nombre de la persona
con mayor edad.
Programa:
public class CadenaDeCaracteres1 {

String nombre1,nombre2;
int edad1,edad2;
System.out.print("Ingrese el nombre:");
nombre1=teclado.next();
System.out.print("Ingrese edad:");
edad1=teclado.nextInt();
System.out.print("Ingrese el nombre:");
System.out.print("La persona de mayor edad es:");
if (edad1>edad2) {
System.out.print(nombre1);
} else {
System.out.print(nombre2);
}
}
}
Para almacenar un nombre debemos definir una variable de tipo String y su ingreso por
teclado se hace llamando al método next() del objeto teclado:
95
La primera salvedad que tenemos que hacer cuando utilizamos el método next() es que solo
nos permite ingresar una cadena de caracteres con la excepción del espacio en blanco (es
decir debemos ingresar un nombre de persona y no su nombre y apellido separado por un
espacio en blanco)
Veamos que existe otro método llamado nextLine() que nos permite cargar espacios en
blanco pero para su uso se complica cuando cargamos otras valores de tipo distinto a String
(por ejemplo int, float etc.)
Ejemplo 2:
Solicitar el ingreso del apellido, nombre y edad de dos personas. Mostrar el nombre de la
persona con mayor edad. Realizar la carga del apellido y nombre en una variable de tipo
String.
Programa:

String apenom1,apenom2;
int edad1,edad2;
System.out.print("Ingrese el apellido y el nombre:");
apenom1=teclado.nextLine();
teclado.nextLine();
System.out.print("La persona de mayor edad es:");
if (edad1>edad2) {
System.out.print(apenom1);
} else {
System.out.print(apenom2);
}
}
}
Cuando se ingresa una cadena con caracteres en blanco debemos tener en cuenta en llamar
al método nextLine().
96
Una dificultad se presenta si llamamos al método nextLine() y previamente hemos llamado

al método nextInt(), esto debido a que luego de ejecutar el método nextInt() queda
almacenado en el objeto de la clase Scanner el caracter "Enter" y si llamamos
inmediatamente al método nextLine() este almacena dicho valor de tecla y continúa con el
flujo del programa. Para solucionar este problema debemos generar un código similar a:
teclado.nextLine();
Como vemos llamamos al método nextLine() dos veces, la primera retorna la tecla "Enter"
y la segunda se queda esperando que ingresemos el apellido y nombre (tener en cuenta que
esto es necesario solo si previamente se llamó al método nextInt() o nextFloat().
Ejemplo 3:
Solicitar el ingreso de dos apellidos. Mostrar un mensaje si son iguales o distintos.
Programa:

String apellido1,apellido2;
System.out.print("Ingrese primer apellido:");
apellido1=teclado.next();
System.out.print("Ingrese segundo apellido:");
apellido2=teclado.next();
if (apellido1.equals(apellido2)) {
System.out.print("Los apellidos son iguales");
} else {
System.out.print("Los apellidos son distintos");
}
}
}
Para comparar si el contenido de dos String son iguales no podemos utilizar el operador ==.
Debemos utilizar un método de la clase String llamado equals y pasar como parámetro el
String con el que queremos compararlo:
if (apellido1.equals(apellido2)) {
97
El método equals retorna verdadero si los contenidos de los dos String son exactamente
iguales, esto hace que se ejecute el bloque del verdadero.
Recordemos que hemos utilizado el método next() para la carga de los String, luego esto
hace que no podamos ingresar un apellido con espacios en blanco (podemos probar que si
ingresamos por ejemplo "Rodriguez Rodriguez" en el primer apellido, luego se carga la
cadena "Rodriguez" en la variable apellido1 y "Rodriguez" en la variable apellido2 (con
esto hacemos notar que cada vez que ingresamos un espacio en blanco cuando utilizamos el
método next() los caracteres que siguen al espacio en blanco son recuperados en la
siguiente llamada al método next())
El método equals retorna verdadero si los contenidos de los dos String son exactamente
iguales, es decir si cargamos "Martinez" en apellido1 y "martinez" en apellido2 luego el
método equals retorna falso ya que no es lo mismo la "M" mayúscula y la "m" minúscula.
En el caso que necesitemos considerar igual caracteres mayúsculas y minúsculas podemos

utilizar el método equalsIgnoreCase:
if (apellido1.equalsIgnoreCase(apellido2)) {
System.out.print("Los apellidos son iguales sin tener
en cuenta mayúsculas y minúsculas");
}
else {
System.out.print("Los apellidos son distintos sin tener
en cuenta mayúsculas y minúsculas");
}
98
Introducción a la programación Orientada a objetos
Declaración de una clase y definición de objetos.
La programación orientada a objetos se basa en la programación de clases; a diferencia de

la programación estructurada, que está centrada en las funciones.
Una clase es un molde del que luego se pueden crear múltiples objetos, con similares
características.
Una clase es una plantilla (molde), que define atributos (variables) y métodos (funciones)
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada
objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un
objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente
dicho.
La estructura de una clase es:
class [nombre de la clase] {

[atributos o variables de la clase]
[métodos o funciones de la clase]
[main]
}
Ejemplo 1:
Confeccionar una clase que permita carga el nombre y la edad de una persona. Mostrar los
datos cargados. Imprimir un mensaje si es mayor de edad (edad>=18)
Programa:
public class Persona {
private Scanner teclado;
private String nombre;
private int edad;
public void inicializar() {

teclado=new Scanner(System.in);
System.out.print("Ingrese nombre:");
nombre=teclado.next();
edad=teclado.nextInt();
99
public void imprimir() {

System.out.println("Nombre:"+nombre);
System.out.println("Edad:"+edad);
}
public void esMayorEdad() {

if (edad>=18) {
System.out.print(nombre+" es mayor de edad.");
} else {
System.out.print(nombre+" no es mayor de edad.");
}
}

Persona persona1;
persona1=new Persona();
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
}
}
El nombre de la clase debe hacer referencia al concepto (en este caso la hemos llamado
Persona):
public class Persona {
Los atributos los definimos dentro de la clase pero fuera de la main:

private int edad;
Veremos más adelante que un atributo es normalmente definido con la cláusula private (con
esto no permitimos el acceso al atributo desde otras clases)
A los atributos se tiene acceso desde cualquier función o método de la clase (salvo la main)
Luego de definir los atributos de la clase debemos declarar los métodos o funciones de la
clase. La sintaxis es parecida a la main (sin la cláusula static):

100
}
En el método inicializar (que será el primero que deberemos llamar desde la main) creamos
el objeto de la clase Scanner y cargamos por teclado los atributos nombre y edad. Como
podemos ver el método inicializar puede hacer acceso a los tres atributos de la clase
Persona.
El segundo método tiene por objetivo imprimir el contenido de los atributos nombre y edad
(los datos de los atributos se cargaron al ejecutarse previamente el método inicializar:

}
El tercer método tiene por objetivo mostrar un mensaje si la persona es mayor o no de edad:

if (edad>=18) {
} else {
}
}
Por último en la main declaramos un objeto de la clase Persona y llamamos a los métodos
en un orden adecuado:

Persona persona1;
persona1=new Persona();
persona1.inicializar();
persona1.imprimir();
persona1.esMayorEdad();
}
Persona persona1; //Declaración del objeto

persona1=new Persona(); //Creación del objeto
persona1.inicializar(); //Llamada de un método
Ejemplo 2:
Desarrollar un programa que cargue los lados de un triángulo e implemente los siguientes
métodos: inicializar los atributos, imprimir el valor del lado mayor y otro método que
muestre si es equilátero o no.
101
Programa:
public class Triangulo {
private int lado1,lado2,lado3;

System.out.print("Medida lado 1:");
lado1=teclado.nextInt();
}
public void ladoMayor() {

System.out.print("Lado mayor:");
if (lado1>lado2 && lado1>lado3) {
System.out.println(lado1);
} else {
if (lado2>lado3) {
} else {
}
}
}
public void esEquilatero() {

if (lado1==lado2 && lado1==lado3) {
System.out.print("Es un triángulo equilátero");
} else {
System.out.print("No es un triángulo
equilátero");
}
}
public static void main(String []ar) {

Triangulo triangulo1=new Triangulo();
triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
}
}
102
Todos los problemas que requieran la entrada de datos por teclado debemos definir un
atributo de la clase Scanner:
Este problema requiere definir tres atributos de tipo entero donde almacenamos los valores
de los lados del triángulo:
private int lado1,lado2,lado3;
El primer método que deberá llamarse desde la main es el inicializar donde creamos el
objeto de la clase Scanner y cargamos los tres atributos por teclado:

}
El método ladoMayor muestra el valor mayor de los tres enteros ingresados:
public void ladoMayor() {

System.out.print("Lado mayor:");
if (lado1>lado2 && lado1>lado3) {
} else {
if (lado2>lado3) {
} else {
}
}
}
Como podemos observar cuando un problema se vuelve más complejo es más fácil y
ordenado separar los distintos algoritmos en varios métodos y no codificar todo en la main.
El último método de esta clase verifica si los tres enteros ingresados son iguales:
public void esEquilatero() {

if (lado1==lado2 && lado1==lado3) {
System.out.print("Es un triángulo equilátero");
} else {
103
System.out.print("No es un triángulo
equilátero");
}
}
En la main creamos un objeto de la clase Triangulo y llamamos los métodos respectivos:
public static void main(String []ar) {

Triangulo triangulo1=new Triangulo();
triangulo1.inicializar();
triangulo1.ladoMayor();
triangulo1.esEquilatero();
}
Ejemplo 3:
Desarrollar una clase que represente un punto en el plano y tenga los siguientes métodos:
cargar los valores de x e y, imprimir en que cuadrante se encuentra dicho punto (concepto
matemático, primer cuadrante si x e y son positivas, si x<0 e y>0 segundo cuadrante, etc.)
Programa:
public class Punto {
int x,y;

System.out.print("Ingrese coordenada x :");
x=teclado.nextInt();
System.out.print("Ingrese coordenada y :");
y=teclado.nextInt();
}
void imprimirCuadrante() {
if (x>0 && y>0) {
System.out.print("Se encuentra en el primer
cuadrante.");
} else {
if (x<0 && y>0) {
System.out.print("Se encuentra en el segundo
cuadrante.");
} else {
if (x<0 && y<0) {
System.out.print("Se encuentra en el
tercer cuadrante.");
} else {
104
if (x>0 && y<0) {

System.out.print("Se encuentra en el cuarto
cuadrante.");
}
else {
System.out.print("El punto no está en un
cuadrante.");
}
}
}
}
}

Punto punto1;
punto1=new Punto();
punto1.inicializar();
punto1.imprimirCuadrante();
}
}
Definimos tres atributos (el objeto de la clase Scanner y los dos enteros donde
almacenamos la coordenada x e y del punto:

int x,y;
El método inicializar crea el objeto de la clase Scanner y pide cargar las coordenadas x e y:

System.out.print("Ingrese coordenada x :");
x=teclado.nextInt();
System.out.print("Ingrese coordenada y :");
y=teclado.nextInt();
}
El segundo método mediante un conjunto de if verificamos en que cuadrante se encuentra

el punto ingresado:
void imprimirCuadrante() {
if (x>0 && y>0) {
System.out.print("Se encuentra en el primer
cuadrante.");
} else {
if (x<0 && y>0) {
105
System.out.print("Se encuentra en el segundo

cuadrante.");
} else {
if (x<0 && y<0) {
tercer cuadrante.");
} else {
if (x>0 && y<0) {
cuarto cuadrante.");
} else {
System.out.print("El punto no está en
un cuadrante.");
}
}
}
}
}
La main no tiene grandes diferencias con los problemas realizados anteriormente,

declaramos un objeto de la clase Punto, creamos el objeto mediante el operador new y
seguidamente llamamos a los métodos inicializar e imprimirCuadrante en ese orden:

Punto punto1;
punto1=new Punto();
punto1.inicializar();
punto1.imprimirCuadrante();
}
Ejemplo 4:
Desarrollar una clase que represente un Cuadrado y tenga los siguientes métodos: cargar el
valor de su lado, imprimir su perímetro y su superficie.
Programa:
public class Cuadrado {
int lado;

System.out.print("Ingrese valor del lado :");
lado=teclado.nextInt();
}
106
public void imprimirPerimetro() {

int perimetro;
perimetro=lado*4;
System.out.println("El perímetro es:"+perimetro);
}
public void imprimirSuperficie() {

int superficie;
superficie=lado*lado;
System.out.println("La superficie es:"+superficie);
}

Cuadrado cuadrado1;
cuadrado1=new Cuadrado();
cuadrado1.inicializar();
cuadrado1.imprimirPerimetro();
cuadrado1.imprimirSuperficie();
}
}
En este problema es interesante ver como no definimos dos atributos donde se almacenan la
superficie y el perímetro del cuadrado, esto debido a que solo estos datos se los requiere en
el método donde se imprimen:
public void imprimirPerimetro() {

int perimetro;
perimetro=lado*4;
System.out.println("El perímetro es:"+perimetro);
}
Esto significa que la variable perímetro es una variable local al método

imprimirPerimetro. Esta variable es local a dicho método y solo se la puede acceder
dentro del método. La diferencia fundamental entre una variable local y un atributo de la
clase es que al atributo se lo puede acceder desde cualquier método de la clase y la variable
local solo existe mientras se está ejecutando el método.
107
1) Hacer una clase que represente un empleado. Definir como atributos su nombre y su
sueldo. Confeccionar los métodos para la carga, otro para imprimir sus datos y por
último uno que imprima un mensaje si debe pagar impuestos (si el sueldo supera a
3000)
2) Implementar la clase operaciones. Se deben cargar dos valores enteros, calcular su

suma, resta, multiplicación y división, cada una en un método, imprimir dichos
resultados.
Declaración de métodos
Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un único método
(lo que hicimos en los primeros programas de este libro) es dividir todas las
responsabilidades de las clase en un conjunto de métodos.
Un método hemos visto que tiene la siguiente sintaxis:
public void [nombre del método]() {

[algoritmo]
}
Veremos que hay varios tipos de métodos:
Métodos con parámetros
Un método puede tener parámetros:
public void [nombre del método]([parámetros]) {

[algoritmo]
}
Los parámetros los podemos imaginar como variables locales al método, pero su valor se
inicializa con datos que llegan cuando lo llamamos.
Ejemplo 1:
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la
tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.
108
Programa:
public class TablaMultiplicar {
public void cargarValor() {
int valor;
do {
if (valor!=-1) {
calcular(valor);
}
} while (valor!=-1);
}
public void calcular(int v) {

for(int f=v;f<=v*10;f=f+v) {
System.out.print(f+"-");
}
}

TablaMultiplicar tabla;
tabla=new TablaMultiplicar();
tabla.cargarValor();
}
}
En esta clase no hemos definido ningún atributo, ya que el objeto de la clase Scanner lo
requerimos en un solo método, por ello lo definimos como una variable local.
El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del
método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la
variable f con el valor que llega en el parámetro. Luego de cada ejecución del for
incrementamos el contador f con el valor de v.
public void calcular(int v) {

for(int f=v;f<=v*10;f=f+v) {
System.out.print(f+"-");
}
}
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede
tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan
por coma)
109
El método cargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por
teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le
pasamos por teclado:
public void cargarValor() {

int valor;
do {
if (valor!=-1) {
calcular(valor);
}
} while (valor!=-1);
}
Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos
el dato a enviar (debe ser un valor o variable entera)
En este problema en la main solo llamamos al método cargarValor, ya que el método

calcular luego es llamado por el método cargarValor:

TablaMultiplicar tabla;
tabla=new TablaMultiplicar();
tabla.cargarValor();
}
Métodos que retornan un dato
Un método puede retornar un dato:
public [tipo de dato] [nombre del método]([parámetros]) {

[algoritmo]
return [tipo de dato]
}
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre
del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el
momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave
return con el valor respectivo.
110
Ejemplo 2:
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el
mayor y el menor.
Programa:
public class MayorMenor {
public void cargarValores() {
int valor1=teclado.nextInt();
System.out.print("Ingrese tercer valor:");
int mayor,menor;
mayor=calcularMayor(valor1,valor2,valor3);
menor=calcularMenor(valor1,valor2,valor3);
System.out.println("El valor mayor de los tres
es:"+mayor);
System.out.println("El valor menor de los tres
es:"+menor);
}
public int calcularMayor(int v1,int v2,int v3) {

int m;
if(v1>>v2 && v1>v3) {
m=v1;
} else {
if(v2>v3) {
m=v2;
} else {
m=v3;
}
}
return m;
}
public int calcularMenor(int v1,int v2,int v3) {

int m;
if(v1<v2 && v1<v3) {
m=v1;
} else {
if(v2<v3) {
m=v2;
} else {
m=v3;
}
111
}
return m;
}

MayorMenor maymen=new MayorMenor();
maymen.cargarValores();
}
}
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo
visto en conceptos anteriores:

int m;
if(v1>v2 && v1>v3) {
m=v1;
} else {
if(v2>v3) {
m=v2;
} else {
m=v3;
}
}
return m;
}
Lo primero que podemos observar que el método retorna un entero y recibe tres
parámetros:
Dentro del método verificamos cual de los tres parámetros almacena un valor mayor, a este
valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta
variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método cargarCalores:
mayor=calcularMayor(valor1,valor2,valor3);
Debemos asignar a una variable el valor devuelto por el método calcularMayor. Luego el
contenido de la variable mayor lo mostramos:
System.out.println("El valor mayor de los tres es:"+mayor);
La lógica es similar para el cálculo del menor.
112
Arreglos unidimensionales (vectores)
Hemos empleado variables de distinto tipo para el almacenamiento de datos (variables int,
float, String) En esta sección veremos otros tipos de variables que permiten almacenar un
conjunto de datos en una única variable.
Un vector es una estructura de datos que permite almacenar un CONJUNTO de datos del
MISMO tipo.
Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a
cada elemento del mismo (componente)
Ejemplo 1:
Se desea guardar los sueldos de 5 trabajadores.
Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento

los 5 sueldos almacenados en memoria.
Empleando un vector solo se requiere definir un único nombre y accedemos a cada

elemento por medio del subíndice.
Programa:
public class PruebaVector1 {
private int[] sueldos;
public void cargar()

{
sueldos=new int[5];
for(int f=0;f<5;f++) {
System.out.print("Ingrese valor de la
componente:");
sueldos[f]=teclado.nextInt();
}
}

System.out.println(sueldos[f]);
}
}
113

PruebaVector1 pv=new PruebaVector1();
pv.cargar();
pv.imprimir();
}
}
Para la declaración de un vector le antecedemos al nombre los corchetes abiertos y

cerrados:
Lo definimos como atributo de la clase ya que lo utilizaremos en los dos métodos.
En el método de cargar lo primero que hacemos es crear el vector (en java los vectores son
objetos por lo que es necesario proceder a su creación mediante el operador new):
sueldos=new int[5];
Cuando creamos el vector indicamos entre corchetes la cantidad de elementos que se

pueden almacenar posteriormente en el mismo.
Para cargar cada componente debemos indicar entre corchetes que elemento del vector
estamos accediendo:
System.out.print("Ingrese valor de la componente:");
}
La estructura de programación que más se adapta para cargar en forma completa las
componentes de un vector es un for, ya que sabemos de antemano la cantidad de valores a
cargar.
Cuando f vale cero estamos accediendo a la primer componente del vector (en nuestro caso
sería):
sueldos[0]=teclado.nextInt();
Lo mas común es utilizar una estructura repetitiva for para recorrer cada componente del
vector.
Utilizar el for nos reduce la cantidad de código, si no utilizo un for debería en forma
secuencial implementar el siguiente código:
114

componente:");


La impresión de las componentes del vector lo hacemos en el otro método:

}
}
Siempre que queremos acceder a una componente del vector debemos indicar entre
corchetes la componente, dicho valor comienza a numerarse en cero y continua hasta un
número menos del tamaño del vector, en nuestro caso creamos el vector con 5 elementos:
sueldos=new int[5];
Por último en este programa creamos un objeto en la main y llamamos a lo métodos de

cargar e imprimir el vector:

pv.cargar();
pv.imprimir();
}
Ejemplo 2:
Definir un vector de 5 componentes de tipo float que representen las alturas de 5 personas.
Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio
y cuántas más bajas.
Programa:
115
private float[] alturas;
private float promedio;
public void cargar() {

alturas=new float[5];
System.out.print("Ingrese la altura de la
persona:");
alturas[f]=teclado.nextFloat();
}
}
public void calcularPromedio() {

float suma;
suma=0;
suma=suma+alturas[f];
}
promedio=suma/5;
System.out.println("Promedio de alturas:"+promedio);
}
public void mayoresMenores() {

int may,men;
may=0;
men=0;
if (alturas[f]>promedio) {
may++;
} else {
if (alturas[f]<promedio) {
men++;
}
}
}
System.out.println("Cantidad de personas mayores al
promedio:"+may);
System.out.println("Cantidad de personas menores al
promedio:"+men);
}

PruebaVector2 pv2=new PruebaVector2();
pv2.cargar();
pv2.calcularPromedio();
pv2.mayoresMenores();
116
}
}
Definimos como atributo un vector donde almacenaremos las alturas:
private float[] alturas;
En la carga creamos el vector indicando que reserve espacio para 5 componentes:
alturas=new float[5];
Procedemos seguidamente a cargar todos sus elementos:
System.out.print("Ingrese la altura de la persona:");
alturas[f]=teclado.nextFloat();
}
En otro método procedemos a sumar todas sus componentes y obtener el promedio. El

promedio lo almacenamos en un atributo de la clase ya que lo necesitamos en otro método:
public void calcularPromedio() {

float suma;
suma=0;
suma=suma+alturas[f];
}
promedio=suma/5;
System.out.println("Promedio de alturas:"+promedio);
}
Por último en un tercer método comparamos cada componente del vector con el atributo
promedio, si el valor almacenado supera al promedio incrementamos un contador en caso
que sea menor al promedio incrementamos otro contador:
public void mayoresMenores() {

int may,men;
may=0;
men=0;
if (alturas[f]>promedio) {
may++;
} else {
if (alturas[f]<promedio) {
men++;
}
117
}
}
System.out.println("Cantidad de personas mayores al
promedio:"+may);
System.out.println("Cantidad de personas menores al
promedio:"+men);
}
Observación:
En este problema podemos observar una ventaja de tener almacenadas todas las alturas de
las personas. Si no conociéramos los vectores tenemos que cargar otra vez las alturas por
teclado para compararlas con el promedio.
Mientras el programa está en ejecución tenemos el vector alturas a nuestra disposición. Es

importante tener en cuenta que cuando finaliza la ejecución del programa se pierde el
contenido de todas las variables (simples y vectores)
Ejemplo 3:
Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la
mañana y 4 por la tarde).
Hacer un programa que permita almacenar los sueldos de los empleados agrupados por
turno. Imprimir los gastos en sueldos de cada turno.
Programa:
private float[] turnoMan;
private float[] turnoTar;

turnoMan=new float[4];
turnoTar=new float[4];
System.out.println("Sueldos de empleados del turno de
la mañana.");
System.out.print("Ingrese sueldo:");
turnoMan[f]=teclado.nextFloat();
}
la tarde.");
118
turnoTar[f]=teclado.nextFloat();
}
}
public void calcularGastos() {

float man=0;
float tar=0;
for(int f=0;f<4;f++){
man=man+turnoMan[f];
tar=tar+turnoTar[f];
}
System.out.println("Total de gastos del turno de la
mañana:"+man);
tarde:"+tar);
}
public static void main(String[] ar){

pv.cargar();
pv.calcularGastos();
}
}
Definimos dos atributos de tipo vector donde almacenaremos los sueldos de los empleados
de cada turno:
private float[] turnoMan;

private float[] turnoTar;
Creamos los vectores con cuatro elementos cada uno:
turnoMan=new float[4];
turnoTar=new float[4];
Mediante dos estructuras repetitivas procedemos a cargar cada vector:

la mañana.");
turnoMan[f]=teclado.nextFloat();
}
la tarde.");
119
turnoTar[f]=teclado.nextFloat();
}
En otro método procedemos a sumar las componentes de cada vector y mostrar dichos
acumuladores:
float man=0;
float tar=0;
for(int f=0;f<4;f++){
man=man+turnoMan[f];
tar=tar+turnoTar[f];
}
mañana:"+man);
tarde:"+tar);
1) Desarrollar un programa que permita ingresar un vector de 8 elementos, e informe:

El valor acumulado de todos los elementos del vector.
El valor acumulado de los elementos del vector que sean mayores a 36.
Cantidad de valores mayores a 50.
2) Realizar un programa que pida la carga de dos vectores numéricos enteros de 4

elementos. Obtener la suma de los dos vectores, dicho resultado guardarlo en un
tercer vector del mismo tamaño. Sumar componente a componente.
3) Se tienen las notas del primer parcial de los alumnos de dos cursos, el curso A y el
curso B, cada curso cuenta con 5 alumnos. Realizar un programa que muestre el
curso que obtuvo el mayor promedio general.
4) Cargar un vector de 10 elementos y verificar posteriormente si el mismo está

ordenado de menor a mayor.
120
Arreglos multidimensionales (matrices)
Una matriz es una estructura de datos que permite almacenar un CONJUNTO de datos del
MISMO tipo.
Con un único nombre se define la matriz y por medio de DOS subíndices hacemos
referencia a cada elemento de la misma (componente)
La figura muestra una matriz de 3 filas y 5 columnas. Para hacer referencia a cada elemento
debemos indicar primero la fila y luego la columna, por ejemplo en la componente 1,4 se
almacena el valor 97.
En este ejemplo almacenamos valores enteros. Todos los elementos de la matriz deben ser
del mismo tipo (int, float, String etc.)
Las filas y columnas comienzan a numerarse a partir de cero, similar a los vectores.
Una matriz se la puede representar por un conjunto de vectores.
Ejemplo1:
Crear una matriz de 3 filas por 5 columnas con elementos de tipo int, cargar sus
componentes y luego imprimirlas.
Programa:
public class Matriz1 {
private int[][] mat;

mat=new int[3][5];
121
for(int c=0;c<5;c++) {
System.out.print("Ingrese componente:");
mat[f][c]=teclado.nextInt();
}
}
}

System.out.print(mat[f][c]+" ");
}
System.out.println();
}
}

Matriz1 ma=new Matriz1();
ma.cargar();
ma.imprimir();
}
}
Para definir una matriz debemos antecederle los corchetes abiertos y cerrados dos veces:
De esta forma el compilador de Java puede diferenciar los vectores de las matrices.
Para crear la matriz, es decir hacer la reserva de espacio de todas sus componentes debemos
utilizar el operador new y mediante dos subíndices indicamos la cantidad de filas y
columnas que tendrá la matriz:
mat=new int[3][5];
Luego debemos pasar a cargar sus 15 componentes (cada fila almacena 5 componentes y
tenemos 3 filas).
Lo más cómodo es utilizar un for anidado, el primer for que incrementa el contador f lo
utilizamos para recorrer las filas y el contador interno llamado c lo utilizamos para recorrer
las columnas.
Cada vez que se repite en forma completa el for interno se carga una fila completa, primero
se carga la fila cero en forma completa, luego la fila uno y finalmente la fila 2.
Siempre que accedemos a una posición de la matriz debemos disponer dos subíndices que
hagan referencia a la fila y columna mat[f][c]):
122
}
}
Para imprimir la matriz de forma similar utilizamos dos for para acceder a cada elemento
de la matriz:
}
}
}
Cada vez que se ejecuta todas las vueltas del for interno tenemos en pantalla una fila
completa de la matriz, por eso pasamos a ejecutar un salto de línea (con esto logramos que
en pantalla los datos aparezcan en forma matricial):
Ejemplo 2:
Crear y cargar una matriz de 4 filas por 4 columnas. Imprimir la diagonal principal.
x - - -
- x - -
- - x -
- - - x
Programa:

mat=new int[4][4];
123
}
}
}
public void imprimirDiagonalPrincipal() {

for(int k=0;k<4;k++) {
System.out.print(mat[k][k]+" ");
}
}

ma.cargar();
ma.imprimirDiagonalPrincipal();
}
}
La definición, creación y carga de la matriz no varían con el ejemplo anterior.

Para imprimir la diagonal principal de la matriz lo más conveniente es utilizar un for que se
repita 4 veces y disponer como subíndice dicho contador (los elementos de la diagonal
principal coinciden los valores de la fila y columna):
for(int k=0;k<4;k++) {
System.out.print(mat[k][k]+" ");
}
Ejemplo 3:
Crear y cargar una matriz de 3 filas por 4 columnas. Imprimir la primer fila. Imprimir la
última fila e imprimir la primer columna.
Programa:

mat=new int[3][4];
124
}
}
}
public void primerFila() {

System.out.println("Primer fila de la matriz:");
System.out.println(mat[0][c]);
}
}
public void ultimaFila() {

System.out.println("Ultima fila de la matriz:");
}
}
public void primerColumna() {

System.out.println("Primer columna:");
System.out.println(mat[f][0]);
}
}

ma.cargar();
ma.primerFila();
ma.ultimaFila();
ma.primerColumna();
}
}
Creamos una matriz de 3 filas y 4 columnas:
mat=new int[3][4];
Luego de cargarla el primer método que codificamos es el que imprimime la primer fila.
Disponemos un for para recorrer las columnas, ya que la fila siempre será la cero. Como
son cuatro los elementos de la primer fila el for se repite esta cantidad de veces:
System.out.println("Primer fila de la matriz:");

}
125
Para imprimir la última fila el algoritmo es similar, disponemos un for que se repita 4 veces
y en el subíndice de la fila disponemos el valor 2 (ya que la matriz tiene 3 filas):
System.out.println("Ultima fila de la matriz:");

}
Para imprimir la primer columna el for debe repetirse 3 veces ya que la matriz tiene 3 filas.
Dejamos constante el subíndice de la columna con el valor cero:
System.out.println("Primer columna:");
System.out.println(mat[f][0]);
}
Problema propuesto
Crear una matriz de 2 filas y 5 columnas. Realizar la carga de componentes por columna
(es decir primero ingresar toda la primer columna, luego la segunda columna y así
sucesivamente). Imprimir luego la matriz.
126
Constructores de la clase
En Java podemos definir un método que se ejecute inicialmente y en forma automática.

Este método se lo llama constructor.
El constructor tiene las siguientes características:
• Tiene el mismo nombre de la clase.

• Es el primer método que se ejecuta.
• Se ejecuta en forma automática.
• No puede retornar datos.
• Se ejecuta una única vez.
• Un constructor tiene por objetivo inicializar atributos.
Ejemplo 1:
Se desea guardar los sueldos de 5 operarios en un vector. Realizar la creación y carga del
vector en el constructor.
Programa:
public class Operarios {
public Operarios()
{
sueldos=new int[5];
componente:");
}
}

}
}
127

Operarios op=new Operarios();
op.imprimir();
}
}
Como podemos ver es el mismo problema que resolvimos cuando vimos vectores. La
diferencia es que hemos sustituido el método cargar con el constructor:
public Operarios()
{
sueldos=new int[5];
componente:");
}
}
Como la clase se llama Operarios el constructor tiene el mismo nombre, no disponemos la

palabra clave void ya que el constructor no puede retornar datos.
La ventaja de plantear un constructor en lugar de definir un método con cualquier nombre

es que se llamará en forma automática cuando se crea un objeto de esta clase:

Operarios op=new Operarios();
Cuando se crea el objeto op se llama al método constructor.
Finalmente llamamos al método imprimir:
op.imprimir();
Ejemplo 2:
Plantear una clase llamada Alumno y definir como atributos su nombre y su edad. En el
constructor realizar la carga de datos. Definir otros dos métodos para imprimir los datos
ingresados y un mensaje si es mayor o no de edad (edad >=18)
128
Programa:
public class Alumno {
private int edad;
public Alumno() {
}

}

if (edad>=18) {
} else {
}
}

Alumno alumno1=new Alumno();
alumno1.imprimir();
alumno1.esMayorEdad();
}
}
Declaramos la clase Persona, sus tres atributos y definimos el constructor con el mismo
nombre de la clase:
public class Alumno {

private int edad;
public Alumno() {
129
}
En la main el constructor se llama en forma automática cuando creamos un objeto de la

clase Alumno:

Alumno alumno1=new Alumno();
Los otros dos métodos deben llamarse por su nombre y en el orden que necesitemos:
alumno1.imprimir();
alumno1.esMayorEdad();
1) Hacer una clase que represente un empleado. Definir como atributos su nombre y su
sueldo. En el constructor cargar los atributos y luego en otro método imprimir sus
datos y por último uno que imprima un mensaje si debe pagar impuestos (si el
sueldo supera a 3000)
2) Implementar la clase operaciones. Se deben cargar dos valores enteros en el

constructor, calcular su suma, resta, multiplicación y división, cada una en un
método, imprimir dichos resultados.
La Clase String
La clase String está orientada a manejar cadenas de caracteres. Hasta este momento hemos
utilizado algunos métodos de la clase String (equals, compareTo)
Ahora veremos otro conjunto de métodos de uso común de la clase String:
boolean equals(String s1)

Retorna true si el contenido de caracteres del parámetro s1 es exactamente igual a la cadena
de caracteres del objeto que llama al método equals.
130
boolean equalsIgnoreCase(String s1)
El funcionamiento es casi exactamente igual que el método equals con la diferencia que no
tiene en cuenta mayúsculas y minúsculas (si comparamos 'Ana' y 'ana' luego el método
equalsIgnoreCase retorna true)
int compareTo(String s1)
Este método retorna un 0 si el contenido de s1 es exactamente igual al String contenido por

el objeto que llama al método compareTo. Retorna un valor >0 si el contenido del String
que llama al método compareTo es mayor alfabéticamente al parámetro s1.
char charAt(int pos)
Retorna un caracter del String, llega al método la posición del caracter a extraer.
int length()
Retorna la cantidad de caracteres almacenados en el String.
String substring(int pos1,int pos2)
Retorna un substring a partir de la posición indicada en el parámetro pos1 hasta la posición

pos2 sin incluir dicha posición.
int indexOf(String s1)
Retorna -1 si el String que le pasamos como parámetro no está contenida en la cadena del
objeto que llama al método. En caso que se encuentre contenido el String s1 retorna la
posición donde comienza a repetirse.
String toUpperCase()
Retorna un String con el contenido convertido todo a mayúsculas.
String toLowerCase()
Retorna un String con el contenido convertido todo a minúsculas.
131
Ejemplo 1:
Confeccionar una clase que solicite el ingreso de dos String y luego emplee los métodos
más comunes de la clase String.
Programa:
public class Cadena1 {
String cad1;
String cad2;
System.out.print("Ingrese la primer cadena:");
cad1=teclado.nextLine();
System.out.print("Ingrese la segunda cadena:");
if (cad1.equals(cad2)==true) {
System.out.println(cad1+" es exactamente igual a
"+cad2);
} else {
System.out.println(cad1+" no es exactamente igual
a "+cad2);
}
if (cad1.equalsIgnoreCase(cad2)==true) {
System.out.println(cad1+" es igual a "+cad2+" sin
tener en cuenta mayúsculas/minúsculas");
} else {
System.out.println(cad1+" no es igual a "+cad2+"
sin tener en cuenta mayúsculas/minúsculas");
}
if (cad1.compareTo(cad2)==0) {
System.out.println(cad1+" es exactamente igual a
"+cad2);
} else {
if (cad1.compareTo(cad2)>0) {
System.out.println(cad1+ " es mayor
alfabéticamente que "+cad2);
} else {
System.out.println(cad2+ " es mayor
alfabéticamente que "+cad1);
}
}
char carac1=cad1.charAt(0);
System.out.println("El primer caracter de "+cad1+" es
"+carac1);
int largo=cad1.length();
System.out.println("El largo del String "+cad1+" es
"+largo);
132
String cad3=cad1.substring(0,3);
System.out.println("Los primeros tres caracteres de
"+cad1+" son "+cad3);
int posi=cad1.indexOf(cad2);
if (posi==-1) {
System.out.println(cad2+" no está contenido en
"+cad1);
} else {
System.out.println(cad2+" está contenido en
"+cad1+" a partir de la
posición "+posi);
}
System.out.println(cad1+ " convertido a mayúsculas es
"+cad1.toUpperCase());
System.out.println(cad1+ " convertido a minúsculas es
"+cad1.toLowerCase());
}
}
Para cargar los dos String utilizamos en este caso el método nextLine para permitir ingresar
espacios en blanco:
System.out.print("Ingrese la primer cadena:");

System.out.print("Ingrese la segunda cadena:");
1) Realizar una clase, que permita cargar una dirección de mail en el constructor, luego
en otro método mostrar un mensaje si contiene el caracter '@'.
2) Cargar un String por teclado e implementar los siguientes métodos:
a) Imprimir la primera mitad de los caracteres de la cadena.

b) Imprimir el último carácter.
c) Imprimirlo en forma inversa.
d) Imprimir cada carácter del String separado con un guión.
e) Imprimir la cantidad de vocales almacenadas.
f) Implementar un método que verifique si la cadena se lee igual de izquierda a derecha
tanto como de derecha a izquierda (ej. neuquen se lee igual en las dos direcciones)
3) Desarrollar un programa que solicite la carga de una clave. La clase debe tener dos
métodos uno para la carga y otro que muestre si la clave es la correcta (la clave a
comparar es "123abc")
133
4) Confeccionar un programa que permita cargar los nombres de 5 personas y sus mail,
luego implementar los siguientes métodos:
a) Mostrar por pantalla los datos.
b) Consulta del mail ingresando su nombre.
c) Mostrar los mail que no tienen el carácter @.
5) Codifique un programa que permita cargar una oración por teclado, luego mostrar cada
palabra ingresada en una línea distinta.
Por ejemplo si se ingresa:
La mañana está fría.
Debe aparecer:
La
mañana
está
fría.
134
Colaboración de clases
Normalmente un problema resuelto con la metodología de programación orientada a

objetos no interviene una sola clase, sino que hay muchas clases que interactúan y se
comunican.
Plantearemos un problema separando las actividades en dos clases.
Ejemplo 1:
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco
requiere que al final del día calcule la cantidad de dinero que hay depositada.
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Cliente y la clase Banco.
Luego debemos definir los atributos y los métodos de cada clase:
Cliente
atributos:
nombre
monto
métodos:
constructor
depositar
extraer
retornarMonto
Banco
atributos:
3 Cliente (3 objetos de la clase Cliente)
1 Scanner (Para poder hacer la entrada de datos por teclado)
métodos:
constructor
operar
depositosTotales
Creamos un proyecto en Netbeans llamado: Proyecto1 y dentro del proyecto creamos dos
clases llamadas: Cliente y Banco.
135
Programa:
public class Cliente {

private int monto;
public Cliente(String nom) {

nombre=nom;
monto=0;
}
public void depositar(int m) {

monto=monto+m;
}
public void extraer(int m) {

monto=monto-m;
}
public int retornarMonto() {

return monto;
}

System.out.println(nombre+" tiene depositado la suma
de "+monto);
}
}
public class Banco {

private Cliente cliente1,cliente2,cliente3;
public Banco() {
cliente1=new Cliente("Juan");
cliente2=new Cliente("Ana");
cliente3=new Cliente("Pedro");
}
public void operar() {

cliente1.depositar (100);
cliente3.extraer (150);
}
public void depositosTotales ()

{
136
int t = cliente1.retornarMonto () +
cliente2.retornarMonto () + cliente3.retornarMonto ();
System.out.println ("El total de dinero en el banco
es:" + t);
cliente1.imprimir();
}

Banco banco1=new Banco();
banco1.operar();
banco1.depositosTotales();
}
}
Analizando la implementación del problema:
Los atributos de una clase normalmente son privados para que no se tenga acceso
directamente desde otra clase, los atributos son modificados por los métodos de la misma
clase:

private int monto;
El constructor recibe como parámetro el nombre del cliente y lo almacena en el atributo

respectivo e inicializa el atributo monto en cero:
public Cliente(String nom) {

nombre=nom;
monto=0;
}
Los métodos depositar y extraer actualizan el atributo monto con el dinero que llega como
parámetro (para simplificar el problema no hemos validado que cuando se extrae dinero el
atributo monto quede con un valor negativo):
public void depositar(int m) {

monto=monto+m;
}
public void extraer(int m) {

monto=monto-m;
}
137
El método retornarMonto tiene por objetivo comunicar al Banco la cantidad de dinero que
tiene el cliente (recordemos que como el atributo monto es privado de la clase, debemos
tener un método que lo retorne):
public int retornarMonto() {

return monto;
}
Por último el método imprimir muestra nombre y el monto de dinero del cliente:

System.out.println(nombre+" tiene depositado la suma
de "+monto);
}
Como podemos observar la clase Cliente no tiene función main. Entonces donde definimos
objetos de la clase Cliente?
La respuesta a esta pregunta es que en la clase Banco definimos tres objetos de la clase
Cliente.
Veamos ahora la clase Banco que requiere la colaboración de la clase Cliente.

Primero definimos tres atributos de tipo Cliente:
public class Banco {

private Cliente cliente1,cliente2,cliente3;
En le constructor creamos los tres objetos (cada vez que creamos un objeto de la clase
Cliente debemos pasar a su constructor el nombre del cliente, recordemos que su monto de
depósito se inicializa con cero):
public Banco() {
cliente1=new Cliente("Juan");
cliente2=new Cliente("Ana");
cliente3=new Cliente("Pedro");
}
El método operar del banco (llamamos a los métodos depositar y extraer de los clientes):
public void operar() {

cliente3.extraer (150);
}
138
El método depositosTotales obtiene el monto depositado de cada uno de los tres clientes,
procede a mostrarlos y llama al método imprimir de cada cliente para poder mostrar el
nombre y depósito:
public void depositosTotales ()

{
int t = cliente1.retornarMonto () +
cliente2.retornarMonto () +
cliente3.retornarMonto ();
System.out.println ("El total de dinero en el banco

es:" + t);
}
Por último en la main definimos un objeto de la clase Banco (la clase Banco es la clase
principal en nuestro problema):

Banco banco1=new Banco();
banco1.operar();
banco1.depositosTotales();
}
Ejemplo 2:
Plantear un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres
dados si los tres salen con el mismo valor mostrar un mensaje que "gano", sino "perdió".
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Dado y la clase JuegoDeDados.
Luego los atributos y los métodos de cada clase:
Dado
atributos:
valor
métodos:
tirar
imprimir
retornarValor
139
JuegoDeDados
atributos:
3 Dado (3 objetos de la clase Dado)
métodos;
constructor
jugar
Creamos un proyecto en Eclipse llamado: Proyecto2 y dentro del proyecto creamos dos
clases llamadas: Dado y JuegoDeDados.
Programa:
public class Dado {

private int valor;
public void tirar() {

valor=1+(int)(Math.random()*6);
}

System.out.println("El valor del dado es:"+valor);
}
public int retornarValor() {

return valor;
}
}
public class JuegoDeDados {

private Dado dado1,dado2,dado3;
public JuegoDeDados() {
dado1=new Dado();
dado2=new Dado();
dado3=new Dado();
}
public void jugar() {

dado1.tirar();
dado1.imprimir();
dado2.tirar();
dado2.imprimir();
dado3.tirar();
dado3.imprimir();
if (dado1.retornarValor()==dado2.retornarValor() &&
140
dado1.retornarValor()==dado3.retornarValor()) {
System.out.println("Ganó");
} else {
System.out.println("Perdió");
}
}

JuegoDeDados j=new JuegoDeDados();
j.jugar();
}
}
La clase dado define el atributo "valor" donde almacenamos un valor aleatorio que
representa el número que sale al tirarlo.
public class Dado {

private int valor;
El método tirar almacena el valor aleatorio (para generar un valor aleatorio utilizamos el
método random de la clase Math, el mismo genera un valor real comprendido entre 0 y 1,
pero nunca 0 o 1. Puede ser un valor tan pequeño como 0.0001 o tan grando como 0.9999.
Luego este valor generado multiplicado por 6 y antecediendo (int) obtenemos la parte
entera de dicho producto):
public void tirar() {

valor=1+(int)(Math.random()*6);
}
Como vemos le sumamos uno ya que el producto del valor aleatorio con seis puede generar
números enteros entre 0 y 5.
El método imprimir de la clase Dado muestra por pantalla el valor del dado:

System.out.println("El valor del dado es:"+valor);
}
Por último el método que retorna el valor del dado (se utiliza en la otra clase para ver si los
tres dados generaron el mismo valor):
public int retornarValor() {

return valor;
}
141
La clase JuegoDeDatos define tres atributos de la clase Dado (con esto decimos que la clase
Dado colabora con la clase JuegoDeDados):
public class JuegoDeDados {

private Dado dado1,dado2,dado3;
En el constructor procedemos a crear los tres objetos de la clase Dado:
public JuegoDeDados() {
dado1=new Dado();
dado2=new Dado();
dado3=new Dado();
}
En el método jugar llamamos al método tirar de cada dado, pedimos que se imprima el
valor generado y finalmente procedemos a verificar si se ganó o no:
public void jugar() {

dado1.tirar();
dado1.imprimir();
dado2.tirar();
dado2.imprimir();
dado3.tirar();
dado3.imprimir();
if (dado1.retornarValor()==dado2.retornarValor() &&
dado1.retornarValor()==dado3.retornarValor()) {
System.out.println("Ganó");
} else {
System.out.println("Perdió");
}
}
En la main creamos solo un objeto de la clase principal (en este caso la clase principal es el
JuegoDeDados):

JuegoDeDados j=new JuegoDeDados();
j.jugar();
}
142
Problema propuesto
Plantear una clase Club y otra clase Socio.

La clase Socio debe tener los siguientes atributos privados: nombre y la antigüedad en el
club (en años). En el constructor pedir la carga del nombre y su antigüedad. La clase Club
debe tener como atributos 3 objetos de la clase Socio. Definir una responsabilidad para
imprimir el nombre del socio con mayor antigüedad en el club.
Herencia
Vimos en el concepto anterior que dos clases pueden estar relacionadas por la colaboración.
Ahora veremos otro tipo de relaciones entre clases que es la Herencia.
La herencia significa que se pueden crear nuevas clases partiendo de clases existentes, que
tendrá todas los atributos y los métodos de su 'superclase' o 'clase padre' y además se le
podrán añadir otros atributos y métodos propios.
clase padre
Clase de la que desciende o deriva una clase. Las clases hijas (descendientes) heredan
(incorporan) automáticamente los atributos y métodos de la la clase padre.
Subclase
Clase desciendiente de otra. Hereda automáticamente los atributos y métodos de su

superclase. Es una especialización de otra clase. Admiten la definición de nuevos atributos
y métodos para aumentar la especialización de la clase.
Veamos algunos ejemplos teóricos de herencia:
1) Imaginemos la clase Vehículo. Qué clases podrían derivar de ella?
Vehículo
Colectivo Moto Carro
Honda Toyota
Siempre hacia abajo en la jerarquía hay una especialización (las subclases añaden nuevos
atributos y métodos.
143
2) Imaginemos la clase Software. Qué clases podrían derivar de ella?
Software
DeAplicacion De sistemas
ProcesadorTexto PlanillaDeCalculo SistemaOperativo
Word Writer Excel Calc Linux Windows
El primer tipo de relación que habíamos visto entre dos clases, es la de colaboración.
Recordemos que es cuando una clase contiene un objeto de otra clase como atributo.
Cuando la relación entre dos clases es del tipo "...tiene un..." o "...es parte de...", no
debemos implementar herencia. Estamos frente a una relación de colaboración de clases no
de herencia.
Si tenemos una ClaseA y otra ClaseB y notamos que entre ellas existe una relacion de tipo
"... tiene un...", no debe implementarse herencia sino declarar en la clase ClaseA un atributo
de la clase ClaseB.
Por ejemplo: tenemos una clase Auto, una clase Rueda y una clase Volante. Vemos que la
relación entre ellas es: Auto "...tiene 4..." Rueda, Volante "...es parte de..." Auto; pero la
clase Auto no debe derivar de Rueda ni Volante de Auto porque la relación no es de tipo-
subtipo sino de colaboración. Debemos declarar en la clase Auto 4 atributos de tipo Rueda
y 1 de tipo Volante.
Luego si vemos que dos clase responden a la pregunta ClaseA "..es un.." ClaseB es posible
que haya una relación de herencia.
Por ejemplo:
Auto "es un" Vehiculo

Circulo "es una" Figura
Mouse "es un" DispositivoEntrada
Suma "es una" Operacion
Ejemplo 1:
Ahora plantearemos el primer problema utilizando herencia. Supongamos que necesitamos

implementar dos clases que llamaremos Suma y Resta. Cada clase tiene como atributo
valor1, valor2 y resultado. Los métodos a definir son cargar1 (que inicializa el atributo
valor1), carga2 (que inicializa el atributo valor2), operar (que en el caso de la clase "Suma"
suma los dos atributos y en el caso de la clase "Resta" hace la diferencia entre valor1 y
valor2, y otro método mostrarResultado.
144
Si analizamos ambas clases encontramos que muchos atributos y métodos son idénticos. En
estos casos es bueno definir una clase padre que agrupe dichos atributos y
responsabilidades comunes.
La relación de herencia que podemos disponer para este problema es:
Operación
Suma Resta
Solamente el método operar es distinto para las clases Suma y Resta (esto hace que no lo
podamos disponer en la clase Operacion), luego los métodos cargar1, cargar2 y
mostrarResultado son idénticos a las dos clases, esto hace que podamos disponerlos en la
clase Operacion. Lo mismo los atributos valor1, valor2 y resultado se definirán en la clase
padre Operacion.
Crear un proyecto y luego crear cuatro clases llamadas: Operacion, Suma, Resta y Prueba
Programa:
public class Operacion {
protected Scanner teclado;
protected int valor1;
protected int resultado;
public Operacion() {
}
public void cargar1() {

System.out.print("Ingrese el primer valor:");
valor1=teclado.nextInt();
}

System.out.print("Ingrese el segundo valor:");
}
public void mostrarResultado() {

System.out.println(resultado);
}
}
145
public class Suma extends Operacion{

void operar() {
resultado=valor1+valor2;
}
}
public class Resta extends Operacion {

public void operar(){
resultado=valor1-valor2;
}
}
public class Prueba {

Suma suma1=new Suma();
suma1.cargar1();
suma1.cargar2();
suma1.operar();
System.out.print("El resultado de la suma es:");
suma1.mostrarResultado();
Resta resta1=new Resta();
resta1.cargar1();
resta1.cargar2();
resta1.operar();
System.out.print("El resultado de la resta es:");
resta1.mostrarResultado();
}
}
La clase Operación define los cuatro atributos:
public class Operacion {
protected Scanner teclado;
protected int resultado;
146
Ya veremos que definimos los atributos con este nuevo modificador de acceso (protected)
para que la subclase tenga acceso a dichos atributos. Si los definimos private las subclases
no pueden acceder a dichos atributos.
Los métodos de la clase Operacion son:
public Operacion() {
}

System.out.print("Ingrese el primer valor:");
}

System.out.print("Ingrese el segundo valor:");
}
public void mostrarResultado() {

System.out.println(resultado);
}
Ahora veamos como es la sintaxis para indicar que una clase hereda de otra:
public class Suma extends Operacion{
Utilizamos la palabra clave extends y seguidamente el nombre de la clase padre (con esto
estamos indicando que todos los métodos y atributos de la clase Operación son también
métodos de la clase Suma.
Luego la característica que añade la clase Suma es el siguiente método:
void operar() {
resultado=valor1+valor2;
}
El método operar puede acceder a los atributos heredados (siempre y cuando los mismos se
declaren protected, en caso que sean private si bien lo hereda de la clase padre solo los
pueden modificar métodos de dicha clase padre.
Ahora podemos decir que la clase Suma tiene cinco métodos (cuatro heredados y uno
propio) y 3 atributos (todos heredados)
Luego en otra clase creamos un objeto de la clase Suma:
public class Prueba {
147

Suma suma1=new Suma();
suma1.cargar1();
suma1.cargar2();
suma1.operar();
System.out.print("El resultado de la suma es:");
suma1.mostrarResultado();
Resta resta1=new Resta();
resta1.cargar1();
resta1.cargar2();
resta1.operar();
System.out.print("El resultado de la resta es:");
resta1.mostrarResultado();
}
}
Podemos llamar tanto al método propio de la clase Suma "operar()" como a los métodos
heredados. Quien utilice la clase Suma solo debe conocer que métodos públicos tiene
(independientemente que pertenezcan a la clase Suma o a una clase superior)
La lógica es similar para declarar la clase Resta.
La clase Operación agrupa en este caso un conjunto de atributos y métodos comunes a un

conjunto de subclases (Suma, Resta). No tiene sentido definir objetos de la clase Operacion.
El planteo de jerarquías de clases es una tarea compleja que requiere un perfecto

entendimiento de todas las clases que intervienen en un problema, cuales son sus atributos
y responsabilidades.
1) Crear una clase Persona que tenga como atributos el nombre y la edad. Definir
como responsabilidades un método que cargue los datos personales y otro que los
imprima.
2) Plantear una segunda clase Empleado que herede de la clase Persona. Añadir un
atributo sueldo y los métodos de cargar el sueldo e imprimir su sueldo.
3) Definir un objeto de la clase Persona y llamar a sus métodos. También crear un

objeto de la clase Empleado y llamar a sus métodos.
148
Matrices y vectores paralelos
Dependiendo de la complejidad del problema podemos necesitar el empleo de vectores y

matrices paralelos.
Ejemplo 1:
Se tiene la siguiente información:

· Nombres de 4 empleados.
· Ingresos en concepto de sueldo, cobrado por cada empleado, en los últimos 3 meses.
Confeccionar el programa para:
a) Realizar la carga de la información mencionada.

b) Generar un vector que contenga el ingreso acumulado en sueldos en los últimos 3 meses
para cada empleado.
c) Mostrar por pantalla el total pagado en sueldos a todos los empleados en los últimos 3
meses
d) Obtener el nombre del empleado que tuvo el mayor ingreso acumulado
Programa:
private String[] empleados;
private int[][] sueldos;
private int[] sueldostot;

empleados=new String[4];
sueldos=new int[4][3];
for(int f=0;f<empleados.length;f++){
149
System.out.print("Ingrese el nombre del

empleado:");
empleados[f]=teclado.next();
for(int c=0;c<sueldos[f].length;c++) {
sueldos[f][c]=teclado.nextInt();
}
}
}
public void calcularSumaSueldos() {

sueldostot=new int[4];
for(int f=0;f<sueldos.length;f++) {
int suma=0;
suma=suma+sueldos[f][c];
}
sueldostot[f]=suma;
}
}
public void imprimirTotalPagado() {

System.out.println("Total de sueldos pagados por
empleado.");
for(int f=0;f<sueldostot.length;f++) {
System.out.println(empleados[f]+" -
"+sueldostot[f]);
}
}
public void empleadoMayorSueldo() {

int may=sueldostot[0];
String nom=empleados[0];
if (sueldostot[f]>may) {
may=sueldostot[f];
nom=empleados[f];
}
}
System.out.println("El empleado con mayor sueldo es
"+ nom + " que tiene un sueldo de "+may);
}

ma.cargar();
ma.calcularSumaSueldos();
ma.imprimirTotalPagado();
ma.empleadoMayorSueldo();
}
}
150
Para resolver este problema lo primero que hacemos es definir una matriz donde se
almacenarán los sueldos mensuales de cada empleado, un vector de tipo String donde
almacenaremos los nombre de cada empleado y finalmente definimos un vector paralelo a
la matriz donde almacenaremos la suma de cada fila de la matriz:
private String[] empleados;

private int[][] sueldos;
private int[] sueldostot;
En el método de cargar inicializamos el vector con los nombres de los empleados y la

matriz paralela donde se almacenan los últimos tres sueldos (previo a cargar procedemos a
crear el vector y la matriz):
empleados=new String[4];
sueldos=new int[4][3];
for(int f=0;f<empleados.length;f++){
System.out.print("Ingrese el nombre del
empleado:");
empleados[f]=teclado.next();
sueldos[f][c]=teclado.nextInt();
}
}
El método sumar sueldos crea el vector donde se almacenará la suma de cada fila de la
matriz. Mediante dos for recorremos toda la matriz y sumamos cada fila:
sueldostot=new int[4];
for(int f=0;f<sueldos.length;f++) {
int suma=0;
suma=suma+sueldos[f][c];
}
sueldostot[f]=suma;
}
El método imprimirTotalPagado tiene por objetivo mostrar los dos vectores (el de nombre
de los empleados y el que almacena la suma de cada fila de la matriz):
System.out.println(empleados[f]+" -
"+sueldostot[f]);
}
151
Por último para obtener el nombre del empleado con mayor sueldo acumulado debemos
inicializar dos variables auxiliares con el primer elemento del vector de empleados y en otra
auxiliar guardamos la primer componente del vector sueldostot:
int may=sueldostot[0];
String nom=empleados[0];
if (sueldostot[f]>may) {
may=sueldostot[f];
nom=empleados[f];
}
}
System.out.println("El empleado con mayor sueldo es
"+ nom + " que tiene un sueldo de "+may);
Problema propuesto
Se desea saber la temperatura media trimestral de cuatro paises. Para ello se tiene como
dato las temperaturas medias mensuales de dichos paises. Se debe ingresar el nombre del
país y seguidamente las tres temperaturas medias mensuales.
Seleccionar las estructuras de datos adecuadas para el almacenamiento de los datos en

memoria.
a - Cargar por teclado los nombres de los paises y las temperaturas medias mensuales.
b - Imprimir los nombres de las paises y las temperaturas medias mensuales de las
mismas.
c - Calcular la temperatura media trimestral de cada país.
c - Imprimr los nombres de las provincias y las temperaturas medias trimestrales.
b - Imprimir el nombre de la provincia con la temperatura media trimestral mayor.
152
Matrices irregulares
Java nos permite crear matrices irregulares. Se dice que una matriz es irregular si la
cantidad de elementos de cada fila varía. Luego podemos imaginar una matriz irregular:
Como podemos ver la fila cero tiene reservado dos espacios, la fila uno reserva cuatro
espacios y la última fila reserva espacio para tres componentes.
Para crear la matriz irregular del gráfico:
La declaración es la misma que para matrices regulares:
int [][] mat;
Primero creamos la cantidad de filas dejando vacío el espacio que indica la cantidad de
columnas:
mat=new int[3][];
Luego debemos ir creando cada fila de la matriz indicando la cantidad de elementos de la

respectiva fila:
mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];
Luego la forma para acceder a sus componentes es similar a las matrices regulares, siempre
teniendo en cuenta y validando que exista dicha componente:
mat[0][0]=120;
Dará un error si queremos cargar la tercer componente de la fila cero (esto debido a que no
existe):
mat[0][2]=230;
153
Luego si queremos saber la cantidad de filas que tiene la matriz:
Sytem.out.println(mat.length);
Si queremos saber la cantidad de elementos de una determinada fila:
Sytem.out.println("Cantidad de elementos de la fila

0:"+mat[0].length);
1:"+mat[1].length);
2:"+mat[2].length);
Ejemplo 1:
Confeccionaremos un programa que permita crear una matriz irregular y luego imprimir la
matriz en forma completa.
Programa:
public class MatrizIrregular1 {

System.out.print("Cuantas fila tiene la matriz:");
int filas=teclado.nextInt();
mat=new int[filas][];
for(int f=0;f<mat.length;f++) {
System.out.print("Cuantas elementos tiene la fila
" + f + ":");
int elementos=teclado.nextInt();
mat[f]=new int[elementos];
for(int c=0;c<mat[f].length;c++) {
}
}
}

}
154
}
}

MatrizIrregular1 ma=new MatrizIrregular1();
ma.cargar();
ma.imprimir();
}
}
Primero creamos la cantidad de filas que tendrá la matriz (en los corchetes para las
columnas no disponemos valor):
System.out.print("Cuantas fila tiene la matriz:");

int filas=teclado.nextInt();
mat=new int[filas][];
Dentro del primer for pedimos que ingrese la cantidad de elementos que tendrá cada fila y
utilizamos el operador new nuevamente, pero en este caso se están creando cada fila de la
matriz (Java trata a cada fila como un vector):
System.out.print("Cuantas elementos tiene la fila
" + f + ":");
int elementos=teclado.nextInt();
mat[f]=new int[elementos];
Dentro del for interno hacemos la carga de las componentes propiamente dicho de la matriz
(podemos ir cargando cada fila a medida que las vamos creando):
}
Luego imprimimos la matriz en forma completa teniendo cuidado las condiciones que
disponemos en cada for.
El primer for se repite tantas veces como filas tiene la matriz: f<mat.length y
el for interno se repite tantas veces como elementos tiene la fila que estamos procesando
c<mat [f].length:
155
}
}
1) Hacer una clase para administrar una matriz irregular de 5 filas y 1 columna la
primer fila, 2 columnas la segunda fila y así sucesivamente hasta 5 columnas la
última fila (crearla sin la intervención del operador)
2) Realizar la carga por teclado e imprimir posteriormente.
3) Confeccionar una clase para administrar los días que han faltado los 3 empleados de
una empresa.
4) Definir un vector de 3 elementos de tipo String para cargar los nombres y una
matriz irregular para cargar los días que han faltado cada empleado (cargar el
número de día que faltó)
• Cada fila de la matriz representan los días de cada empleado.

• Mostrar los empleados con la cantidad de inasistencias.
• Cuál empleado faltó menos días.
156
157

Progra2 Libro

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Progra2 Libro

Cargado por

Copyright:

Formatos disponibles

Curso dinámico de programación

PHP (acrónimo de "PHP: Hypertext Preprocessor") es un lenguaje interpretado de alto nivel

Comunicación entre el cliente y el servidor sin PHP:

1 - Tipeamos en la barra del navegador la dirección y el archivo a solicitar.

Comunicación entre el cliente y el servidor con PHP:

1 - Tipeamos en la barra del navegador la dirección y el archivo a solicitar.

Los nombres de variables comienzan con el carácter $ y son sensibles a mayúsculas y

$dia = 24; //Se declara una variable de tipo integer.

Para la impresión de variables utilizaremos inicialmente el comando echo. Un programa

Variables de tipo string

Una variable de este tipo puede almacenar una serie de caracteres.

Para concatenar string empleamos el operador . (punto)

En pantalla se muestra: Hoy es 10

Es decir, en la cadena, se sustituye el nombre de la variable $dia, con el contenido de la

$nombre='Marco del Cid';

Veremos que en muchos casos se utiliza el concepto de sustitución de variables dentro de

echo "La computadora tiene un precio de $precio";

if, else y else-if. La estructura base de este tipo de instrucciones es la siguiente:

Cuando la ejecución llega al punto donde se encuentra la instrucción if, el programa

De este modo se pueden introducir tantas condiciones como se quiera dentro de la

• == para ver si una variable es igual a otra.

La mejor forma de entender esta estructura condicional es por medio de ejemplos. El

El programa completo es:

Es importante recordar que siempre la condición del if debe ir entre paréntesis. Si la

Las estructuras repetitivas son similares al lenguaje C, JavaScript, Java etc.

for([Inicialización de la variable];[Condición];[Incremento o decremento de la variable])

La segunda estructura repetitiva es:

La condición del while se verifica antes de ingresar al bloque a repetir. Si la misma se

La estructura for permite incrementar una variable de 2 en 2:

for ($f = 2; $f <= 20; $f = $f + 2)

Envío de datos de un FORMULARIO hacia variables PHP :controles text

Una actividad fundamental en PHP es la recolección de datos de un formulario HTML.

La estructura mínima de un formulario es la siguiente: para la entrada de un nombre de

<input type="submit" value="confirmar">

El elemento <form> y </form> nos permite definir un formulario en la página.

<input type="text" name="nombre">

Por último todo formulario tiene un botón de tipo submit:

<input type="submit" value="confirmar">

En nuestro problema sólo mostramos por pantalla el valor ingresado en el formulario

Para analizar este control dispondremos un ejemplo:

La entrada de los dos números se efectúa en dos controles

<input type="text" name="valor1">

Es importante notar que cada text tiene un name DIFERENTE.

<input type="radio" name="radio1" value="suma">sumar

Desde la otra página accederemos al value del control seleccionado.

El vector asociativo $_REQUEST tiene tres componentes:

En la componente $_REQUEST['radio1'] almacena la cadena "suma" o "resta" según cual

Con dos if verificamos cual operación está seleccionada y procedemos a efectuarla:

echo "La suma es:" . $suma;

En la página que procesa el formulario mostrar el nombre de la persona y un mensaje

El control checkbox tiene dos estados: seleccionado o no seleccionado.

El formulario html tiene el siguiente código:

Lo nuevo en este problema son los dos controles de tipo checkbox:

<input type="checkbox" name="check1">sumar

Es importante notar que cada checkbox tiene un nombre distinto.

Si el checkbox no está seleccionado en el formulario no se crea una entrada en el vector

Mostrar en la página que procesa el formulario la cantidad de deportes que practica.

Lo nuevo que aparece en este formulario es el control de tipo select.

Ahora la página que captura los datos ingresados en el formulario es:

El vector asociativo $_REQUEST almacena en la componente del control select el valor de

Con una serie de if verificamos el valor seleccionado:

La sintaxis de este control es bastante diferente a la del control text:

Si queremos que aparezca inicializado con texto debemos disponerlo en:

<textarea name="curriculum">Hola Mundo</textarea>