Pseudocodigos

 Curso De Java Orientado a Android

Prof. Carlos A. Arroyo

 PESUDOCÓDIGO

 INTRODUCCIÓN

El pseudocódigo (falso lenguaje) es una descripción de alto nivel de un algoritmo que emplea una mezcla de
lenguaje natural con algunas convenciones sintácticas propias de lenguajes de programación, como
asignaciones, ciclos y condicionales. Es utilizado para describir algoritmos en libros y publicaciones
científicas, y como producto intermedio durante el desarrollo de un algoritmo.
El pseudocódigo está pensado para facilitar a las personas el entendimiento de un algoritmo, y por lo tanto
puede omitir detalles irrelevantes que son necesarios en una implementación. Programadores diferentes
suelen utilizar convenciones distintas, que pueden estar basadas en la sintaxis de lenguajes de programación
concretos. Sin embargo, el pseudocódigo en general es comprensible sin necesidad de conocer o utilizar un
entorno de programación específico, y es a la vez suficientemente estructurado para que su implementación
se pueda hacer directamente a partir de él.
¿Para qué sirve el Pseudocódigo? Sirve para escribir programas de computadora en lenguaje natural de tal
manera que se facilite la comprensión, prueba y posterior codificación en un lenguaje de programación
específico.

A continuación se muestra un algoritmo en pseudocódigo para obtener la suma de 2 números:

1. Inicio
2. Solicitar x, y
3. Calcular Suma=x+y
4. Imprimir Suma
5. Salir

 ESTRUCTURA DE UN PSEUDOCÓDIGO

Un programa escrito en pseudocódigo está estructurado en tres secciones principales:
o Cabecera
o Declaraciones
o Cuerpo

CABECERA

En la cabecera de un programa se debe indicar el nombre (identificador) asignado al mismo. La
sintaxis es:
program <nombre_del_programa>;

DECLARACIONES

En esta sección se declaran las constantes (const), los tipos de datos (type), las variables (var), los
precedimientos (procedure) y las funciones (function) definidos por el programador que se usan
en el programa. También se puede indicar tanto la <lista_de_unidades> como la
<lista_de_etiquetas> que se utilicen en el programa. La sintaxis es:  Curso De Java Orientado a Android

  [ uses
       <lista_de_unidades>; ]
  [ label
       <lista_de_etiquetas>; ]
  [ const
       <declaraciones_de_constantes>; ]
  [ type
       <declaraciones_de_tipos_de_datos>; ]
  [ var
       <declaraciones_de_variables>; ]
  [ procedure
       <declaraciones_de_procedimientos>; ]
  [ function
       <declaraciones_de_funciones>; ]

Los caracteres abrir corchete ([) y cerrar corchete (]) se utilizan para indicar que lo que contienen
es opcional.

CUERPO

En el cuerpo se escriben las instrucciones del bloque de instrucciones principal del programa. La
sintaxis es:
  begin
     <instrucción_1>
     <instrucción_2>
      ...
     <instrucción_n>
  end.
begin y end son palabras reservadas que marcan el principio y final de la sección cuerpo.
Ejemplos de Pseudocódigo
Ejemplo: Realizar el pseudocódigo de un programa que permita calcular el área de un rectángulo.
Se debe introducir la base y la altura para poder realizar el cálculo..
Programa; área
Entorno: BASE, ALTURA, AREA son número enteros
Algoritmo:
           escribir “Introduzca la base y la altura”
           leer BASE, ALTURA
           calcular AREA = BASE * ALTURA
           escribir “El área del rectángulo es “AREA
Finprograma  Curso De Java Orientado a Android


Ejemplo: Realizar el pseudocódigo que permita al usuario introducir por teclado dos notas,
calculando la suma y el producto de las notas.
Programa: SumaProducto
Entorno: NOTA1,NOTA2,SUMA,PRODUCTO son números enteros
Algoritmo:
escribir “Introduzca las notas”
leer NOTA1,NOTA2
calcular SUMA = NOTA1 + NOTA2
calcular PRODUCTO = NOTA1 * NOTA2
escribir “La suma de las dos notas es:” SUMA
escribir “El producto de las dos notas es :”PRODUCTO
Finprograma
Ejemplo: Realizar el pseudocódigo de un programa que permita saber si un número es mayor,
menor o igual a cero.
   Programa: ComparaNúmeros
   Entorno: NUMERO es un número entero
Algoritmo:
Escribir “Introduzca un número “
leer NUMERO
SI NUMERO>0  ENTONCES
         escribir “El número introducido es positivo”
SI NO
         SI NUMERO<0 ENTONCES
                escribir “El número introducido es negativo”
         SI NO
                escribir “El número es cero”
         FINSI
FINSI
Finprograma

Supongamos un algoritmo que lea las coordenadas de tres puntos y los mueva tres puntos en la
coordenada x y escriba el resultado en algún dispositivo de salida:
ALGORITMO lee_tres_vertices
ENTRADA: las coordenadas (x,y) de tres puntos
SALIDA: las coordenadas (x,y) de los tres puntos movidos 3 puntos hacia la derecha.
VARIABLES: i:entera
x,y: real
INICIO
PARA i=1 HASTA 3 CON INCREMENTO +1
ESCRIBE "Abscisa del punto número ", i  Curso De Java Orientado a Android


LEER x
ESCRIBE "Ordenada del punto número ", i
LEER Y
ESCRIBE "El punto es (" x+3","y")"
FIN_PARA
FIN

El programa equivalente a este algoritmo se muestra a continuación. Como podemos apreciar en
un programa en Pascal es importantísimo no olvidar detalles de sintaxis. Por ejemplo cada
sentencia termina en punto y coma. De cualquier forma es inmediato apreciar los simples cambios
existentes
program lee_tres_vertices;
var x,y:real;
i:integer;
begin
for i:=1 to 3 do
begin
write ('Abscisa del punto número ',i); readln(x);
write ('Ordenada del punto número ',i); readln(y);
writeln (' El punto es (',x+3,',',y,')');
end;
end;

Problema: calcular y mostrar la suma de los diez primeros números entre 1 y 1000 que sean
divisibles por uno dado.
programa suma_divisibles
variables natural : divisor, suma, contador, número
inicio programa
divisor   leer ‘Introduce el divisor: ’
suma   0
contador   0
para número desde 1 hasta 1000 hacer
si divisor divide a número entonces
suma   suma + número
contador   contador + 1
               fin si
               si contador = 10 entonces
interrumpir
               fin si
fin para

escribir ‘La suma es’, suma
fin programa  Curso De Java Orientado a Android

CONTADORES

Un contador es una variable de tipo entera que se debe inicializar con el valor 0 (cero) la primera vez y luego
va incrementando su valor en 1 (uno).

EJEMPLO:

Se leen las notas obtenidas por los alumnos de una materia determinada. Se pide realizar un algoritmo
que permita obtener la cantidad de alumnos con nota mayor que 6. El ingreso de la informacion finaliza
con nota igual a cero.

COMIENZO

real nota
entero ctanotas
Leer nota
ctanotas = 0
Mientras (nota <> 0)
Si ( nota > 6)
 ctanotas = ctanotas+1
FinSI
Leer nota
Fin Mientras
Escribir "cantidad de alumnos con nota mayor que 6", ctanotas
FIN
En este ejemplo, ctanotas se usa una variable contador, la cual se inicializa en 0 al comienzo del algoritmo e
incrementa su valor en 1, siempre y cuando la nota corresponda a alumnos que cumplen con la condición
pedida.

ACUMULADORES O SUMADORES

Un acumulador es una variable de tipo entera que se debe inicializar con el valor 0 (cero) la primera vez y
luego va incrementando su valor en una constante o variable.
Si el valor de esa constante o variable es igual a 1, entonces el acumulador es también un contador.

ACUMULADOR Y REGISTRO “W”  Curso De Java Orientado a Android

Los siguientes gráficos representan un diagrama simplificado de la arquitectura interna del camino de los
datos en la CPU de los microcontroladores PIC y de los microprocesadores tradicionales.
Observamos que la principal diferencia entre ambos se encuentra en la ubicación del registro de trabajo,
que para los PIC’s se denomina W (Working Register), y para los tradicionales es el Acumulador.

ESTRUCTURA DEL PSEUDOCÓDIGO

Los algoritmos pueden tener diferentes opciones de resultado, dependiendo de los datos de entrada que se
proporcionen o del resultado de un determinado proceso.
Alguien acuñó este famoso lema en la programación:
Algoritmos + Estructuras de Datos = Programas

Para lograr que un algoritmo llegue a la solución se pueden utilizar distintas estructuras. Las secuencias, o
también llamadas estructuras de control, tienen como objetivo ofrecer diferentes opciones de solución
dependiendo de determinadas condiciones, las cuales se conocen como sentencias alternativas o selectivas,
ya que se puede elegir, de entre varios un camino de ejecución del programa. Otro de los objetivos de las
secuencias de control es poder ejecutar un proceso varias veces hasta que se cumpla determinada
condición, a estos procesos, en el ambiente de prorgamación se les conoce como bucles o bifurcaciones.
Cuando un algoritmo, futuro programa, no contiene alternativas de selección o procesos repetitivos se le
conoce como flujo secuencial, ya que se ejecutan línea tras línea las instrucciones del proceso hasta llegar al
final.
Las estructuras de control son:
Secuencial
Alternativa
Repetitiva

ESTRUCTURA SECUENCIAL

Sigue el orden de las instrucciones planteadas en el algoritmo, por lo que existe un solo camino para
obtener el resultado. Por ejemplo, calcular el importe determinado de un número de artículos del mismo
precio.
1. Inicio
2. Solicitar Cantidad de Artículos (CA)
3. Solicitar Precio (P)
4. Calcular Importe= CA* P
5. Imprimir Importe
6. Fin

ESTRUCTURA ALTERNATIVA

El algoritmo Cuenta con dos alternativas, de las cuales se selecciona una, dependiendo del resultado que se
obtenga.
Las estructuras alternativas pueden ser:  Curso De Java Orientado a Android

• Estructura de selección simple: Si - Entonces
• Estructura de selección doble: Si -Entonces - Si No
Estructura de selección simple Sí - Entonces. En la siguiente figura se muestra el ejemplo un poco más claro:
Por ejemplo, dada la calificación de un alumno se muestre "reprobado" o "aprobado", la
calificación mayor o igual a 70 es aprobatoria.
1. Inicio
2. Solicitar Calificación (Cal)
3. Establecer Resultado="Reprobado"
4. SI Cal > 70 ENTONCES
        Establecer Resultado="Aprobado"
5. Mostrar Resultado
6. Salir

Estructura de selección doble SI - ENTONCES - SI NO.
En la siguiente figura se muestra el diagrama de flujo y el pseudocódigo para la estructura de selección
doble.
Por ejemplo, diseñar el algoritmo para calcular el salario de un trabajador. Se proporcionan como datos
de entrada el número de horas laboradas por semana y el pago por hora ordinaria. Las horas
extraordinarias se definen como el excedente a 40 horas, y éstas se pagan un 50% más.
1. Inicio
2. Solicitar Horas, Precio_hora
3. SI Horas ≤ 40 ENTONCES
                Salario = Horas * Precio_hora
                SI No
                Salario = (40 * Precio_hora) + [(Horas - 40) * Precio_hora* 1.5)]
4. Imprimir Horas, Salario
5. Fin

ESTRUCTURA REPETITIVA O DE ITERACIÓN

El formato de la estructura de repetición es:
mientras (condición)
instrucción 1
instrucción 2
.....
instrucción n
fin mientras

El resultado de evaluar condición puede ser verdadero o falso:
Mientras sea verdadero, se ejecutarán: instrucción 1,  instrucción 2, ... , instrucción n. Estas instrucciones
dejarán de ejecutarse cuando condición sea falso.  Curso De Java Orientado a Android

Ejemplo:

leer(contraseña)
mientras (contraseña < > "joshua")
imprimir("La contraseña es incorrecta !")
leer (contraseña)
fin-mientras
imprimir("Ha tecleado la contraseña correcta")
Nota: El bucle se repetirá mientras que contraseña <> “joshua” sea verdadero
Salida de resultados
Los resultados de nuestros algoritmos los vamos a mostrar al usuario a través de la instrucción imprimir, que
tiene la siguiente forma general:
Imprimir(argumento 1, argumento 2, argumento 3, ... , argumento n)
Donde los argumentos pueden ser cadenas de caracteres entrecomilladas o variables:
·        Si son cadenas de caracteres entrecomillados se imprime literalmente lo que está entre comillas
·        Si son variables se imprime el contenido de dicha variable (no el nombre)
Ejemplo:
sueldo = 1000
trabajador = “Martínez”
Imprimir( “el sueldo de “, trabajador , ” es “, sueldo , ” Pesos.“ )
La instrucción imprimir, muestra lo siguiente: el sueldo de Martínez es 1000 Pesos.

SUBRUTINAS O PROCEDIMIENTOS

Aunque las funciones son herramientas de programación muy útiles para la resolución de problemas, su
alcance está muy limitado. Con frecuencia, se requieren subprogramas que calculen varios resultados en vez
de uno solo, o que realicen la ordenación de una serie de números, etc.
En estas situaciones la función no es apropiada y se necesita disponer del otro tipo de subprograma: el
procedimiento o subrutina. Un procedimiento o subrutina es un subprograma que ejecuta un proceso
específico. Ningún valor está asociado con el nombre del procedimiento; por consiguiente, no puede ocurrir
en una expresión. Un procedimiento se llama escribiendo su nombre, por ejemplo, SORT, para indicar que
un procedimiento denominado SORT se va a usar. Cuando se invoca el procedimiento, los pasos que lo
definen se ejecutan y a continuación se devuelve el control al programa que le llamó.

Las ventajas de utilizar los procedimientos son:  Curso De Java Orientado a Android


· Facilitan la modularidad y estructuración de los algoritmos.
· Facilitan la lectura e inteligibilidad de los algoritmos.
· Permiten una economización del esfuerzo del programador al poder escribir código reutilizable en muchas
partes de un mismo algoritmo.
· Facilitan la depuración y mantenimiento de los programas.
Ejemplo

Consideramos un subprograma N con dos parámetros formales: i, transmitido por valor, y j, por variable.

Algoritmo M
// variables A, B enteras
var
entero: A, B
inicio
A 2
B 3
Llamar_a N (A, B)
Escribir (A, B)
Fin // algoritmo M
Procedimiento N (E entero: I; E/S entero: j)
// parámetros valor i
//parámetros variables j
inicio
i i + 10

j j + 10
escribir (i, j)
fin_procedimiento
Si se ejecuta el procedimiento N, veamos qué resultados se escribirán:
A y B son parámetros actuales.
I y j son parámetros formales.

DOCUMENTACION

La creación de nuevo sistema informático conlleva diversas  fases que van más allá de la
codificación del mismo. Un modelo tradicional de diseño establece cinco fases:
Análisis,  diseño,  codificación, pruebas y mantenimiento. En la primera se realiza un estudio de
los  requisitos  del  sistema  y  la  viabilidad  del  mismo.  La  fase  de  diseño identifica y define los
elementos que precisa  el proyecto y la interconexión entre los mismos. Del  resultado de estas
dos  fases  se  obtiene un plan que se utilizará como guía  para la  codificación  del  sistema. El
producto  resultante  de  la  codificación  se verá  sometido  a  una  batería  de  pruebas  que
aseguren  la  fiabilidad  del  mismo.   Curso De Java Orientado a Android

Finalmente,  el ciclo de vida de un sistema informático no termina en las pruebas, si no que se
extiende mientras que esté en uso. Así,  es necesario realizar y prever un mantenimiento  del
mismos.  Todas  las  fases  deberían  estar  debidamente documentadas, permitiendo que en  futuro,
se puedan acometer cambios y mejoras en el sistema de manera sencilla. En este modelo clásico
se contempla, además,  que se  pueden  pasar  por las  distintas  fases más  de  una  vez,
permitiendo  retroceder  a una  fase  anterior  si  se  descubre  una  deficiencia  que  impida
continuar.  De  esta manera, el producto final se obtiene mediante una serie de refinamientos
sucesivos.
Al finalizar cada una de las fases, se cumple un hito del proyecto, el cual, suele venir acompañado
de un entregable. Este puede ser, por ejemplo, un nuevo documento o un listado de código, o
una nueva versión de un entregable anterior.

Variables

 Variables

Una variable en Java es un identificador que representa una palabra de memoria que contiene información. El tipo de información
almacenado en una variable sólo puede ser del tipo con que se declaró esa variable.
En Java, todas las variables deben ser declaradas antes de que puedan ser utilizados. La forma básica de una declaración de

variable es la siguiente:

1 type identificador [ = valor][, identificador [= valor] ...] ;
 type, va a ser el tipo de dato que queremos declarar.
 identificador, es el nombre que le queremos dar a la variable.
 valor, es la cantidad o frase que le quieras asignar a la variable que estamos declarando.

Veamos unos ejemplos de cómo declarar variables en Java:

int a, b, c; // declaramos tres variables de tipos int a, b, c.
int d = 3, e, f = 5; // declaramos dos variables de tipos int d y f, pero esta vez la instanciamos. A 'd' le
asignamos 3 y a 'f' le asignamos 5.
double pi = 3.14159; // declaramos un double denominado pi.
char x = 'x'; // la variable x posee un caracter 'x'.

VARIABLES LOCALES

 Las variables locales se declaran en los métodos, constructores, o bloques.
 Se crean cuando se introduce el método, constructor o bloque y la variable serán destruidos una vez que sale el método,
constructor o bloque.
 Son visibles sólo dentro del método declarado, constructor o bloque.
 Se implementan a nivel de pila interna.

Veamos un ejemplo:

public class Curso{
public void kilometrajeCarro(){
int kilometraje = 0;
kilometraje = kilometraje + 7;
System.out.println("El kilometraje del carro es: " + kilometraje);
}

public static void main(String args[]){
Curso curso = new Curso();
curso.kilometrajeCarro();
}
}
 Aquí, el kilometraje es una variable local. Está definida dentro kilometrajeCarro() y su ámbito se limita sólo a
este método.
 Si no inicializamos la variable kilometraje al ejecutar el código este nos daría un error.
Si ejecutamos ese código debería aparecernos lo siguiente:
1 El kilometraje del carro es: 7

VARIABLES DE INSTANCIA

 Las variables de instancia se declaran en una clase, pero fuera de un método, constructor o cualquier bloque.
 Se crean cuando se crea un objeto con el uso de la palabra new y se destruye cuando se destruye el objeto.
 Tienen valores que pueden ser referenciados por más de un método, constructor o bloque.
 Los modificadores de acceso se pueden dar para variables de instancia.
 Poseen valores por defecto. Para los números el valor por defecto es 0, por Booleans es falso y por referencias de objeto es
nulo. Los valores pueden ser asignados en la declaración o en el constructor.
 Se puede acceder directamente mediante una llamada al nombre de la variable dentro de la clase. Sin embargo dentro de los
métodos estáticos debe ser llamado con el nombre completo. Objeto.NombreVariable.

import java.io.*;
public class Persona{
// la variable de instancia nombre puede ser vista por todos los hijos de la clase
public String nombre;
// peso es una variable solo visible por la clase Persona9

private double peso;

// La variable nombre es asignada en el constructor
public Persona (String nombre){
this.nombre = nombre;
}
// Este metodo asigna un peso a la varible peso
public void setPeso(double peso){
this.peso = peso;
}
// Este metodo imprime los datos de la persona
public void imprimirPersona(){
System.out.println("Nombre : " + this.nombre );
System.out.println("Peso :" + this.peso);
}
public static void main(String args[]){
Persona alguien = new Persona("Carlos");
alguien.setPeso(80);
alguien.imprimirPersona();
}
}
Si ejecutamos ese código debería aparecernos lo siguiente:
1
2
Nombre : Carlos
Peso :80.0

VARIABLES DE ESTÁTICAS

 Las variables de clase se declaran con la palabra clave static en una clase, pero fuera de un método, constructor o un bloque.
 Sólo habría una copia de cada variable por clase, independientemente del número de objetos se crean de la misma.
 Las variables estáticas se usan muy poco aparte de ser declarado como constantes.
 Se almacenan en la memoria estática.
 Se crean cuando se inicia el programa y se destruyen cuando el programa se detiene.
 La visibilidad es similar a las variables de instancia. Sin embargo, las variables estáticas se declaran normamentepublic, para
que estén disponibles para los usuarios de la clase.
 Las variables estáticas se puede acceder llamando con el nombre de la clase. NombreClase.NombreVariable.

import java.io.*;
public class Empleado{
// salario es una variable estática privada de la clase empleado
private static double salario;
//
DEPARTAMENTO es una constante

public static final String DEPARTAMENTO = "Desarrollo";
public static void main(String args[]){
salario = 2000;
System.out.println(DEPARTAMENTO + " posee un salario promedio de: " + salary);
}
}
Si ejecutamos ese código debería aparecernos lo siguiente:
1 Desarrollo posee un salario promedio de: 2000

Operadores

Operadores Básicos

Java proporciona un conjunto de operadores para manipular variables. Veremos los operadores más importantes:

 Operadores aritméticos.
 Operadores relacionales.
 Operadores lógicos.
 Operadores de asignación.

Operadores aritméticos

Los operadores aritméticos se utilizan en expresiones matemáticas de la misma manera que se utilizan en el álgebra. En la
siguiente tabla se muestran los operadores aritméticos:

Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println("a + b = " + (a + b) );
System.out.println("a - b = " + (a - b) );
System.out.println("a * b = " + (a * b) );
System.out.println("b / a = " + (b / a) );12
System.out.println("b % a = " + (b % a) );
System.out.println("c % a = " + (c % a) );
System.out.println("a++ = " + (a++) );
System.out.println("b-- = " + (a--) );
// Mira la diferencia entre d++ and ++d
System.out.println("d++ = " + (d++) );
System.out.println("++d = " + (++d) );
}
}

Se ejecutamos este código deberá producir:
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
b-- = 11
d++ = 25
++d = 27

Operadores relacionales

En Java existen los siguientes operadores relacionales:Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}
Se ejecutamos este código deberá producir:

a == b = false
a != b = true
a > b = false

Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}

Se ejecutamos este código deberá producir:

a == b = false
a != b = true
a > b = false
Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
int a = 10;
int b = 20;
System.out.println("a == b = " + (a == b) );
System.out.println("a != b = " + (a != b) );
System.out.println("a > b = " + (a > b) );
System.out.println("a < b = " + (a < b) );
System.out.println("b >= a = " + (b >= a) );
System.out.println("b <= a = " + (b <= a) );
}
}

Se ejecutamos este código deberá producir:

a == b = false
a != b = true
a > b = false4

a < b = true
b >= a = true
b <= a = false

Operadores lógicos

En la siguiente tabla se muestran los operadores lógicos:
Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a && b) = " + !(a && b));
}
}
Se ejecutamos este código deberá producir:

a && b = false
a || b = true
!(a && b) = true
Operadores de asignación

En Java existen las siguientes operadores de asignación:

Veamos un ejemplo:

public class Curso {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c = 0;
c = a + b;
System.out.println("c = a + b = " + c );
c += a;12
System.out.println("c += a = " + c );
c -= a;
System.out.println("c -= a = " + c );
c *= a;
System.out.println("c *= a = " + c );
a = 10;
c = 15;
c /= a ;
System.out.println("c /= a = " + c );
a = 10;
c = 15;
c %= a;
System.out.println("c %= a = " + c );
}
}

Se ejecutamos este código deberá producir:

c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5

Datos

TEMA: TIPOS DE DATOS

A toda variable que se use en un programa, se le debe asociar (generalmente al principio del
programa) un tipo de dato específico.

Un tipo de dato define todo el posible rango de valores que una variable puede tomar al momento
de ejecución del programa y a lo largo de toda la vida útil del propio programa.

Las variables son posiciones de memoria reservadas para almacenar valores. Esto significa que
cuando se crea una variable para reservar algo se crea un espacio en la memoria.

Existen dos tipos de datos disponibles en Java:

1.- Tipos de datos primitivos.
2.- Tipos de datos de referencia.
1.- Tipos de datos primitivos

Hay ocho tipos de datos primitivos soportados por Java. Los tipos de datos primitivos están
predefinidos por el lenguaje y nombrados por una palabra clave. Veamos ahora en detalle acerca
de los ocho tipos de datos primitivos.

Byte

Tipo de datos Byte es un entero de 8 bits.
El valor mínimo es -128 (-2 ^ 7).
El valor máximo es 127 (inclusive) (2 ^ 7 -1).
El valor por defecto es 0.
Tipo de datos Byte se utiliza para ahorrar espacio en grandes conjuntos, sobre todo en el lugar de
los números enteros, ya que un byte es cuatro veces más pequeño que un int.
Ejemplo: byte a = 100, byte b = -50

Short

Tipo de datos Short es un entero de 16 bits.
El valor mínimo es -32,768 (-2 ^ 15).
El valor máximo es de 32.767 (inclusive) (2 ^ 15 -1).
Tipo de datos Short también se puede utilizar para ahorrar memoria como tipo de datos byte. Un
tipo de dato short es 2 veces más pequeño que un int.
El valor por defecto es 0.
Ejemplo: short s = 10000, short r = -20000Int
Tipo de datos int es un entero de 32 bits.
El valor mínimo es -2147483648 (-2 ^ 31).
El valor máximo es 2147483647 (inclusive)(2 ^ 31 -1).
Int. se utiliza generalmente como el tipo de datos predeterminado para los valores enteros a
menos que exista una preocupación acerca de la memoria.
El valor por defecto es 0.
Ejemplo: int a = 100000, int b = -200000

Long

Tipo de datos Long es un entero de 64 bits.
El valor mínimo es -9223372036854775808 (-2 ^ 63).
El valor máximo es 9223372036854775807 (inclusive) (2 ^ 63 -1).
Este tipo se utiliza cuando se necesita una gama más amplia que int.
El valor por defecto es 0.
Ejemplo: long a = 100000, int b =-200000
Float
El Float es un dato de coma flotante de precisión simple de 32 bits.
Float se utiliza principalmente para ahorrar memoria en grandes arrays de números.
El valor por defecto es 0,0 f.
Ejemplo: float f1 = 234.5f

Double

El doble es un dato de coma flotante de doble precisión de 64 bits.
Este tipo de datos se utiliza generalmente como el tipo de datos predeterminado para valores
decimales, en general, la opción por defecto.
El valor por defecto es 0.0 D.
Ejemplo: doble d1 = 123,4

Boolean

Boolean representa un bit de información.
Sólo hay dos posibles valores: true y false.
Este tipo de datos se utiliza para indicadores simples que hacen un seguimiento de condiciones.
El valor predeterminado es falso.Ejemplo: boolean a = true

Char

Char es un carácter Unicode de 16 bits.
El valor mínimo es ‘\u0000′ (o 0).
El valor máximo es ‘\uffff’ (o 65.535 inclusive).
Tipo de datos char se utiliza para almacenar cualquier carácter.
Ejemplo: char letra = 'A'
2.- Tipos de datos de referencia
Las variables de referencia se crean mediante constructores definidos de las clases. Se utilizan
para acceder a los objetos. Estas variables se declaran de un tipo específico que no se puede
cambiar.
Objetos de la Clase, y varios tipos de variables de array están bajo tipo de datos de referencia.
El valor predeterminado de cualquier variable de referencia es nulo.
Una variable de referencia se puede utilizar para referirse a cualquier objeto del tipo declarado o
cualquier tipo compatible.
Ejemplo: Auto unAuto = new Auto ("Ford");
Como se observa es muy similar a las de C o C
++
.

Algoritmos

DESARROLLO DE PROGRAMAS ESTRUCTURADOS

ALGORITMOS

Un ALGORITMO es una secuencia finita ‘bien definida’ de tareas ‘bien definidas’, cada una de las
cuales se puede realizar con una cantidad de recursos finitos.
Se dice que una tarea esta ‘bien definida’, si se sabe de manera precisa las acciones requeridas
para su realización. Aunque los recursos que debe utilizar cada tarea deben ser finitos estos no
están limitados, es decir, si una tarea bien definida requiere una cantidad inmensa (pero finita) de
algún recurso para su realización, dicha tarea puede formar parte de un algoritmo. Además, se
dice que una secuencia de tareas esta ‘bien definida’ si se sabe el orden exacto de ejecución de
cada una de las mismas.

EJECUTAR un algoritmo es realizar las tareas del mismo, en el orden especificado y utilizando los
recursos disponibles.

CARACTERISTICAS DE UN ALGORITMO

Las características que debe poseer una secuencia de tareas para considerarse algoritmo son:
precisión, definitud y finitud.
Precisión Definitud o determinismo Finitud
El algoritmo debe indicar el
orden exacto de ejecución de
cada tarea.
Si se sigue el algoritmo dos o más veces con los
mismos datos de entrada, se deben obtener los
mismos datos de salida.
El algoritmo debe terminar en algún
momento y debe usar una cantidad
de recursos finita.
Dada una cantidad de datos de entrada de un algoritmo, se dice que la cantidad de un recurso
usada por dicho algoritmo para su ejecución determina la complejidad del algoritmo respecto a tal
recurso. Cuando se implementa un algoritmo en un computador digital, los recursos con los que se
cuenta son tiempo de proceso y memoria. Por lo tanto, a un algoritmo implementado en un
computador digital se le pueden calcular sus complejidades temporal y espacial.
[1]
[1]
El estudio de la complejidad de un algoritmo respecto a sus recursos es conocido como
algoritmia, la cual no es tratada en este curso.

TECNICAS PARA LA FORMULACION DE ALGORITMOS

Las técnicas para la formulación de algoritmos más populares son:
1  Diagramas de flujo
2   PseudocódigoCurso De Java Orientado a Android


1 DIAGRAMAS DE FLUJO

Se basan en la utilización de diversos símbolos para representar operaciones específicas. Se les
llama diagramas de flujo porque los símbolos utilizados son de las siguientes formas:
SIMBOLOGIA UTILIZADA EN LOS DIAGRAMAS DE FLUJO
SIMBOLO FUNCIONCurso De Java Orientado a Android


2 PSEUDOCODIGO

Es un lenguaje de especificación de algoritmos. El uso de tal lenguaje hace el paso de codificación
final (esto es, la traducción a un lenguaje de programación) relativamente fácil.
El pseudocódigo nació como un lenguaje similar al lenguaje natural y era un mediopara
representar básicamente las estructuras de control de programación estructurada. Se considera
un primer borrador, dado que el pseudocódigo tiene que traducirse posteriormente a un lenguaje
de programación.
La ventaja del pseudocódigo es que en su uso en la planificación de un programa, el programador
se puede concentrar en la lógica y en las estructuras de control y no preocuparse de las reglas de
un lenguaje específico. Es también fácil modificar el pseudocódigo si se descubren errores o
anomalías en la lógica del programa, además de todo esto es fácil su traducción a lenguajes como
Pascal, C o Basic.Curso De Java Orientado a Android

El pseudocódigo utiliza para representar las acciones sucesivas palabras reservadas (similares a sus
homónimos en los lenguajes de programación), tales como inicio, fin, si-entonces-sino, mientras,
repita-hasta….etc.
Secuencia
Decisión Simple
Decisión Simple
Curso De Java Orientado a Android
Prof. Carlos A. Arroyo
4
El pseudocódigo utiliza para representar las acciones sucesivas palabras reservadas (similares a sus
homónimos en los lenguajes de programación), tales como inicio, fin, si-entonces-sino, mientras,
repita-hasta….etc.
Secuencia
Decisión Simple
Decisión Simple
Curso De Java Orientado a Android
Prof. Carlos A. Arroyo
4
El pseudocódigo utiliza para representar las acciones sucesivas palabras reservadas (similares a sus
homónimos en los lenguajes de programación), tales como inicio, fin, si-entonces-sino, mientras,
repita-hasta….etc.
Secuencia
Decisión Simple
Decisión SimpleCurso De Java Orientado a Android
Prof. Carlos A. Arroyo
5
Iteración Fija
Condicional al inicio
Condicional al finalCurso De Java Orientado a Android
Prof. Carlos A. Arroyo
6
Selección

EJEMPLOS DE ALGORITMOS

1. PROBLEMA: Un estudiante se encuentra en su casa (durmiendo) y debe ir a la universidad (a
tomar la clase de programación), ¿qué debe haga el estudiante?

ALGORITMO:
Inicio
Dormir
haga 1 hasta que suene el despertador (o lo llame la mamá).
Mirar la hora.
¿Hay tiempo suficiente?
Si hay, entonces
Bañarse.
Vestirse.
Desayunar.
Sino,
Vestirse.
Cepillarse los dientes.
Despedirse de la mamá y el papá.
¿Hay tiempo suficiente?
Si, Caminar al paradero.
Sino, Correr al paradero.
Hasta que pase un bus para la universidad haga :
Esperar el bus
Ver a las demás personas que esperan un bus.
Tomar el bus.
Mientras no llegue a la universidad haga :
Seguir en el bus.
Pelear mentalmente con el conductor.
Timbrar.
Bajarse.
Entrar a la universidad.
FinCurso De Java Orientado a Android


2. PROBLEMA: Cambiar la rueda pinchada de un automóvil teniendo un gato mecánico en buen estado, una
rueda de reemplazo y una llave inglesa.

ALGORITMO:
Inicio
PASO 1. Aflojar los tornillos de la rueda pinchada con la llave inglesa.
PASO 2. Ubicar el gato mecánico en su sitio.
PASO 3. Levantar el gato hasta que la rueda pinchada pueda girar
libremente.
PASO 4. Quitar los tornillos y la rueda pinchada.
PASO 5. Poner rueda de repuesto y los tornillos.
PASO 6. Bajar el gato hasta que se pueda liberar.
PASO 7. Sacar el gato de su sitio.
PASO 8. Apretar los tornillos con la llave inglesa.
Fin
3. PROBLEMA: Realizar la suma de los números 2448 y 5746.

ALGORITMO:

Inicio
PASO 1. Colocar los números el primero encima del segundo, de tal
manera que las unidades, decenas, centenas, etc., de los números
queden alineadas. Trazar una línea debajo del segundo número.
PASO 2. Empezar por la columna más a la derecha.
PASO 3. Sumar los dígitos de dicha columna.
PASO 4. Si la suma es mayor a 9 anotar un 1 encima de la siguiente
columna a la izquierda y anotar debajo de la línea las unidades de la
suma. Si no es mayor anotar la suma debajo de la línea.
PASO 5. Si hay más columnas a la izquierda, pasar a la siguiente
columna a la izquierda y volver a 3.
PASO 6. El número debajo de la línea es la solución.
Fin

4. PROBLEMA: Sean los puntos P=(a,b) y Q=(c,d) que definen una recta, encontrar un segmento de
recta
perpendicular a la anterior que pasa por el punto medio de los puntos dados.

ALGORITMO:
InicioCurso De Java Orientado a Android

PASO 1. Trazar un círculo con centro en el punto P que pase por el punto Q.
PASO 2. Trazar un círculo con centro en el punto Q que pase por el punto P.
PASO 3. Trazar un segmento de recta entre los puntos de intersección de las circunferencias
trazadas.
Fin. El segmento de recta trazada es el buscado.Curso De Java Orientado a Android

EJERCICIOS DE ALGORITMOS

Para los siguientes problemas dar un algoritmo y si es posible una ejecución del mismo.
1. Buscar en el directorio telefónico, el número de:
a. José González Pérez
b. Pedro Gómez Bernal.
c. Escribir un algoritmo que sirva para buscar a cualquier persona.
2. Calcular el número de días entre las fechas:
a. Enero 17 de 1972 y Julio 20 de 1973
b. Febrero 2 de 1948 y Agosto 11 de 1966
c. Escribir un algoritmo que sirva para calcular la cantidad de días entre cualquier dos fechas.
3. Solicitar en préstamo algún libro de una biblioteca.
4. haga una caja de cartón con tapa de:
a. 20 cm de largo, por 10 cm de ancho y 5 cm de alto.
b. 10 cm de largo, por 30 cm de ancho y 15 cm de alto.
c. Escribir un algoritmo que sirva para construir una caja de cartón con tapa de cualquier tamaño.
5. Construir un avión de papel.
6. Calcular manualmente la división de cualquier par de números naturales. El resultado también
debe ser un número natural. Escribir un algoritmo para calcular el residuo de la división.Curso De Java Orientado a Android

7. Un juego muy famoso entre dos niños es el de adivina mi número,el cual consiste en que cada
niño trata de adivinar el número pensado por el otro niño. Dicho número generalmente está entre
1 y 100. Las reglas del juego son las siguientes:
a. Cada niño posee un turno en el que trata de averiguar el número del otro.
b. En su turno el primer niño pregunta si un número que dice es el pensado por el segundo.
c. Si el número que ha dicho el primer niño es el que pensó el segundo, este último debe
informarle al primero que ganó.
d. Si el número no es el segundo niño debe decir si su número pensado es menor o mayor al que el
primer niño dijo.
e. Luego el segundo niño tiene su turno y de esta manera se van intercalando hasta que alguno de
los dos gane. Desarrollar un algoritmo para jugar adivina mi número.
8. Una balanza se encuentra en equilibrio cuando el producto de la carga aplicada sobre el brazo
derecho por la longitud de este brazo, es igual al producto de la carga aplicada sobre el brazo
izquierdo por la longitud de este otro brazo. Determinar si la balanza se encuentra en equilibrio si:
a. La longitud del brazo izquierdo es3 m, la del derecho es 2 m, la carga aplicada al brazo izquierdo
es 5 Kg y la carga aplicada al derecho es 7 Kg.
b. La longitud del brazo izquierdo es4 m, la del derecho es 2 m, la carga aplicada al brazo izquierdo
es 4 Kg y la carga aplicada al derecho es 4 Kg.
c. Desarrollar un algoritmo que sirva para cualquier conjunto de valores para las longitudes de los
brazos y las cargas aplicadas.

Programacion estructurada

Programación Estructurada

La visión clásica de la programación estructurada se refiere al control de ejecución. El control de
su ejecución es una de las cuestiones más importantes que hay que tener en cuenta al construir un
programa en un lenguaje de alto nivel. La regla general es que las instrucciones se ejecuten sucesivamente
una tras otra, pero diversas partes del programa se ejecutan o no dependiendo de que se cumpla alguna
condición. Además, hay instrucciones (los bucles) que deben ejecutarse varias veces, ya sea en número fijo o
hasta que se cumpla una condición determinada.
Sin embargo, algunos lenguajes de programación más antiguos (como Fortran) se apoyaban en una sola
instrucción para modificar la secuencia de ejecución de las instrucciones mediante una transferencia
incondicional de su control (con la instrucción goto, del inglés "go to", que significa "ir a"). Pero estas
transferencias arbitrarias del control de ejecución hacen los programas muy poco legibles y difíciles de
comprender. A finales de los años sesenta, surgió una nueva forma de programar que reduce a la mínima
expresión el uso de la instrucción goto y la sustituye por otras más comprensibles.
Esta forma de programar se basa en un famoso teorema, desarrollado por Edsger Dijkstra, que demuestra
que todo programa puede escribirse utilizando únicamente las tres estructuras básicas de control siguientes:

• Secuencia: el bloque secuencial de instrucciones, instrucciones ejecutadas sucesivamente, una detrás de
otra.
• Selección: la instrucción condicional con doble alternativa, de la forma "if condición then instrucción-1 else
instrucción-2".
• Iteración: el bucle condicional "while condición do instrucción", que ejecuta la instrucción repetidamente
mientras la condición se cumpla.
Los programas que utilizan sólo estas tres instrucciones de control básicas o sus variantes (como los bucles
for, repeat o la instrucción condicional switch-case), pero no la instrucción goto, se llaman estructurados.
Ésta es la noción clásica de lo que se entiende por programación estructurada (llamada también
programación sin goto) que hasta la aparición de la programación orientada a objetos se convirtió en la
forma de programar más extendida. Esta última se enfoca hacia la reducción de la cantidad de estructuras
de control para reemplazarlas por otros elementos que hacen uso del concepto de polimorfismo. Aun así los
programadores todavía utilizan las estructuras de control (if, while, for, etc.) para implementar sus
algoritmos porque en muchos casos es la forma más natural de hacerlo.
Una característica importante en un programa estructurado es que puede ser leído en secuencia, desde el
comienzo hasta el final sin perder la continuidad de la tarea que cumple el programa, lo contrario de lo que
ocurre con otros estilos de programación.
Este hecho es importante debido a que es mucho más fácil comprender completamente el trabajo que
realiza una función determinada si todas las instrucciones que influyen en su acción están físicamente
contiguas y encerradas por un bloque. La facilidad de lectura, de comienzo a fin, es una consecuencia de
utilizar solamente tres estructuras de control, y de eliminar la instrucción de transferencia de control goto.

La visión moderna de la programación estructurada: la segmentación
La realización de un programa sin seguir una técnica de programación produce frecuentemente un conjunto
enorme de sentencias cuya ejecución es compleja de seguir, y de entender, pudiendo hacer casi imposible la
depuración de errores y la introducción de mejoras. Se puede incluso llegar al caso de tener que abandonar
el código preexistente porque resulte más fácil empezar de nuevo.
Cuando en la actualidad se habla de programación estructurada, nos solemos referir a la división de un
programa en partes más manejables (usualmente denominadas segmentos o módulos). Una regla prácticapara lograr este propósito es establecer que cada segmento del programa no exceda, en longitud, de una
página de codificación, o sea, alrededor de 50 líneas.
Así, la visión moderna de un programa estructurado es un compuesto de segmentos, los cuales puedan estar
constituidos por unas pocas instrucciones o por una página o más de código. Cada segmento tiene
solamente una entrada y una salida, asumiendo que no poseen bucles infinitos y no tienen instrucciones que
jamás se ejecuten. Encontramos la relación entre ambas visiones en el hecho de que los segmentos se
combinan utilizando las tres estructuras básicas de control mencionadas anteriormente y, por tanto, el
resultado es también un programa estructurado.
Cada una de estas partes englobará funciones y datos íntimamente relacionados semántica o
funcionalmente. En una correcta partición del programa deberá resultar fácil e intuitivo comprender lo que
debe hacer cada módulo.
En una segmentación bien realizada, la comunicación entre segmentos se lleva a cabo de una manera
cuidadosamente controlada. Así, una correcta partición del problema producirá una nula o casi nula
dependencia entre los módulos, pudiéndose entonces trabajar con cada uno de estos módulos de forma
independiente. Este hecho garantizará que los cambios que se efectúen a una parte del programa, durante
la programación original o su mantenimiento, no afecten al resto del programa que no ha sufrido cambios.

Esta técnica de programación conlleva las siguientes ventajas:

a) El coste de resolver varios subproblemas de forma aislada es con frecuencia menor que el de abordar el
problema global.
b) Facilita el trabajo simultáneo en paralelo de distintos grupos de programadores.
c) Posibilita en mayor grado la reutilización del código (especialmente de alguno de los módulos) en futuras
aplicaciones.
Aunque no puede fijarse de antemano el número y tamaño de estos módulos, debe intentarse un
compromiso entre ambos factores. Si nos encontramos ante un módulo con un tamaño excesivo, podremos
dividir éste a su vez en partes (nuevos módulos) más manejables, produciéndose la sucesiva división siempre
desde problemas generales a problemas cada vez menos ambiciosos y, por tanto, de fácil desarrollo y
seguimiento. Así, esta división toma la forma de un árbol cuya raíz es el programa principal que implementa
la solución al problema que afrontamos utilizando uno o varios módulos que realizan partes de dicha
solución por sí solos o invocando a su vez otros módulos que solucionan subproblemas más específicos. A
esta aproximación se la denomina diseño descendente o top-down, como queda esquematizado en la
siguiente figura:
El carácter autocontenido de los módulos o librerías hace que pueda ocultarse el funcionamiento interno de
las funciones contenidas en un módulo, ya que para utilizarlas basta con saber con qué nombre y
argumentos se invocan y qué tipo de valores devuelven.Al reunirlas en un módulo, se realza la relación entre las mismas separándolas del resto del programa.
Esta ocultación de los detalles se denomina encapsulación y se alcanza dividiendo el código del programa en
dos ficheros diferenciados: un fichero (con extensión ".h") que incluye la declaración de los tipos de datos y
de las funciones gracias a lo cual se sabe cómo acceder y utilizar cada una de las mismas y otro (con
extensión ".c") que contiene el código de cada una de las funciones declaradas en el .h.
Al compilar este último queda transformado en código objeto (al cual ya no se puede acceder para su
lectura o modificación) y puede distribuirse conjuntamente con el fichero de declaración (el que acaba en
.h), para su uso por parte de terceros sin riesgo alguno de alteración de la funcionalidad original (ésta quedó
encapsulada u oculta).
Esto es así porque para hacer uso de las funciones incluidas en el módulo únicamente necesitaremos
conocer la información que nos proporciona el fichero de declaración: el nombre, tipos de datos de los
argumentos y valores de retorno de las funciones. No es necesario conocer los detalles de implementación
(sentencias que se ejecutan dentro de una función).
Ejemplo práctico:
Supongamos que queremos desarrollar una aplicación para que dos usuarios jueguen al ajedrez. En primer
lugar, necesitamos una serie de funciones asociadas al tablero: una que coloque todas las piezas de ambos
jugadores en las posiciones iniciales, otra que determine si se ha producido el final de la partida, otra que
confirme la presencia de una pieza del jugador en juego en una determinada casilla, otra que confirme que
el movimiento no se sale del tablero, o que ese tipo de pieza puede realizarlo, y una última que lleve a
efecto el movimiento de una pieza del jugador en juego (eliminando del tablero a otra pieza del jugador
contrario si procede). Para estas últimas puede ser preciso utilizar a su vez otro módulo que represente las
funciones de movimiento asociadas a cada tipo de pieza.
La descomposición en módulos del programa quedaría:
Así, el contenido del fichero de libreríatablero.h sería:
enum columnas { a, b, c, d, e, f, g, h };
struct tablero {
int posx;
enum columnas posy;
struct pieza mipieza;
struct tablero *siguiente;
}
int Final(struct tablero *mitablero);
void Inicio(struct tablero *mitablero);
int Pertenece(struct tablero *mitablero, int posx, enum columnas posy);
void Dibuja(struct tablero *mitablero);
int FueraTablero(struct tablero *mitablero, int x1, enum columnas y1, int x2,
enumcolumnas y2);int Valido_T(struct tablero *mitablero, int x1, enum columnas y1, int x2, enum
columnas y2);
void Mover(struct tablero *mitablero, int x1, enum columnas y1, int x2, enum
columnas y2);
Así, el fichero de declaración pieza.h incluiría el siguiente código:
enum color { blanco, negro };
enum tipo { peon, torre, caballo, alfil, reina, rey }
struct pieza {
enum color micolor;
enum tipo mitipo;
}
int Valido_P(struct pieza *mipieza, int x1, int y1, int x2, int y2);
De esta forma, con el conocimiento público de ambos ficheros de declaración (tablero.h, pieza.h) podremos
hacer uso de las funciones de los módulos tablero y pieza declaradas en estos ficheros, a pesar de nuestra
ignorancia completa de cómo fueron implementadas. Lo ignoramos, ya que no tenemos acceso a los
ficheros de implementación o código fuente (tablero.c, pieza.c); únicamente disponemos del código objeto
(ablero.o, pieza.o) para su ejecución posterior.

Primeros pasos con Eclipse

INTRODUCCIÓN A JAVA

  PRIMEROS PASOS CON ECLIPSE

PERSPECTIVAS Y EMULADOR

1. PERSPECTIVA JAVA

Dados por sabidos los conocimientos básicos sobre Eclipse y la programación en Java, ésta
perspectiva debe ser conocida por todos.
Es la interfaz de usuario (o conjunto de vistas) que provee el ADT Plugin para poder programar en
lenguaje Java. Esta interfaz, proporciona una serie de herramientas (se puede considerar como
una determinada organización de las vistas), para el correcto desarrollo de programas y
aplicaciones, y será la que utilizaremos para programar en este curso de Android.



2. PERSPECTIVA DDMS

En este caso, es el ADT Plugin el que nos proporciona la nueva perspectiva, por lo que lo primero
que hay que hacer es habilitarla. En la pestaña “Window”, seleccionar “Open Perspective” ->
“Other”-> “DDMS”.
Esta perspectiva, sirve para poder programar y realizar debugging
1
 al mismo tiempo, lo que es una
forma muy efectiva de programar.
Aunque se programará con la perspectiva Java, a la hora de corregir errores se puede pasar a la
perspectiva DDMS.

                                                         
http://es.wikipedia.org/wiki/Depuraci%C3%B3n_de_programas  Curso De Java Orientado a Android

3. EMULADOR
Una vez tengamos el proyecto listo para ejecutar, entra en escena el emulador de Android. Éste
proporciona una vista especial para comprobar si la aplicación hace lo que se desea. A
continuación se muestra la vista del emulador
2
 para la versión 2.2 de Android:


                                                         
2
 http://es.wikipedia.org/wiki/Emulador  Curso De Java Orientado a Android


Lo primero que hay que hacer cuando se quiere ejecutar una aplicación, es hacer clic con el botón
derecho sobre el proyecto, y en “Run as” seleccionar “Android Application”, entonces se lanzará el
emulador más apropiado siempre que esté creado (más adelante, se explicará cómo generar los
emuladores).
No se debe parar la ejecución del emulador, dado que cada vez que se ejecuta el mismo, necesita
de muchos recursos del computador, por lo que tarda bastante en lanzarse, y realmente no es
necesario cerrarlo, puesto que cada vez que se lleva a cabo una ejecución del proyecto, la
aplicación se reinstala en el emulador.

Primer ejemplo: Hola Android

Vamos a crear nuestro primer proyecto en Android, pero antes veamos de qué se compone cada
uno. Al generar un nuevo proyecto de Android, dado que estamos utilizando el entorno Eclipse,
éste va a generar automáticamente la distribución de carpetas que contendrá la aplicación, la cuál
será común a todos los proyectos Android.


Veamos el significado de cada carpeta por separado:
Carpeta src:

Toma la totalidad del código fuente
3
 (Java) de la aplicación. En el ejemplo que vamos a llevar a
cabo, Eclipse generará automáticamente el código base de la ventana principal (Activity).
Carpeta res:
Contiene los recursos necesarios para generar una aplicación Android:
.- res/drawable/: Guarda las imágenes y se divide en: drawable-ldpi, drawable-mdpi y drawablehdpi, que dependerán de la resolución del dispositivo.
.- res/raw/: Contiene archivos de propósito general, en otro formato que no es XML.
.- res/layout/: Incluye los archivos que definen el diseño de la interfaz gráfica, siempre en XML.
.- res/values/: Guarda los datos y tipos que utiliza la aplicación, tales como colores, cadenas de
texto, estilos, dimensiones, etc.
                                                         
3
 http://es.wikipedia.org/wiki/C%C3%B3digo_fuente  Curso De Java Orientado a Android


Carpeta gen:
Ésta carpeta guarda un conjunto de archivos (de código Java) creados automáticamente cuando se
compila
4
 el proyecto, para poder dirigir los recursos de la aplicación. El archivo R ajusta
automáticamente todas las referencias a archivos y valores de la aplicación (guardados en la
carpeta res).

Carpeta assets:
Guarda el resto de archivos necesarios para el correcto funcionamiento de la aplicación, como los
archivos de datos o de configuración. La principal diferencia entre los recursos que almacena ésta
carpeta y los que guarda la carpeta “res”, es que los recursos de ésta última generan un
identificador por recurso, identificador
5
 que se encargará de gestionar el fichero R y sólo se podrá
acceder a ellos a través de determinados métodos de acceso, mientras que los recursos
almacenados en la carpeta “assets” no generan identificador alguno y se accederá a ellos a través
de su ruta, como se hace con cualquier otro fichero.

Archivo AndroidManifest.xml:
Éste archivo es uno de los más importantes de cualquier aplicación Android. Se genera
automáticamente al crear el proyecto, y en él se encuentra definida la configuración del proyecto
en XML (Actividades, Intents, los permisos de la aplicación, bibliotecas, etc.).
Por ejemplo, el proyecto que vamos a generar (“Hola Android”), contiene un AndroidManifest.xml
como el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.example.hello"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="8" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:label="@string/app_name"
android:name=".Hola" >
<intent-filter >
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

Otra vista diferente del manifiesto es la siguiente:

                                                         
4
 http://es.wikipedia.org/wiki/Compilador
5
 http://es.wikipedia.org/wiki/Identificador  Curso De Java Orientado a Android


Y por fin, una vez explicadas cada una de las partes que componen el proyecto, vamos a crear
nuestro primer proyecto con Android. Primero hacemos clic en “File”->“New”->“Other”-
>“Android Application Project”, damos a “Next” saldrá la pantalla que se muestra a continuación
(“New Android Aplication”).
Simplemente en “Project Name” poner: HelloAndroid y pulsar “Next”. En la siguiente pantalla,
“damos “Next” nuevamente, en la siguiente podemos aplicarle un ícono, “Next”. Luego en la
siguiente pantalla nos pide que elijamos una actividad, elegiremos la primera, Actividad en Blanco,
Next y finalizar.
En la última pantalla antes de dar por concluida la configuración del nuevo proyecto, “Application
Info”, completar los siguientes campos:
• “Application Name”: Hello, Android
• “Package Name”: org.example.hello
• “Create Activity”: Hello

Con esto ya hemos configurado nuestro primer proyecto, la pantalla nos debería quedar como en
la figura de abajo:
  Curso De Java Orientado a Android


Para ejecutar nuestra aplicación, primero debemos tener creado un emulador de nuestra versión
de Android. Para ello, hacer clic en el símbolo que abre el “Android Virtual Device Manager” (en la
fig. de arriba está marcado con una elipse roja.
Una vez abierto el AVD Manager, Pulsar en el botón New.  Y configuraremos como se muestra en
la siguiente pantalla:
  Curso De Java Orientado a Android

Ahora ya podemos ejecutar nuestra aplicación. Clic con el botón derecho sobre el proyecto, y en
“Run As”, seleccionar “Android Application”. Se lanzará el emulador (hay que tener paciencia,
pues debido a que consume muchos recursos, tardará un rato), y pasado un tiempo, se mostrará
nuestro primer programa en Android: