Lenguaje
Java Orientado a Objetos
Un lenguaje de
computación es la forma de comunicación más avanzada que el hombre ha inventado
y es el medio por la cual se instruye a una computadora o un teléfono inteligente para solucionar todo
tipo problemas de la ciencia y la tecnología. También se pueden programar con
un lenguaje diferentes dispositivos eléctricos y electrónicos que tienen un
microprocesador, así como controlar las máquinas en la tecnología robótica para
la automatización de sistemas de producción, entre muchas otras aplicaciones.
Es el inicio de la era de las maquinas que en el futuro tendrán gran influencia
en la humanidad.
Un programa en
java orientado a objetos define una clase de datos con determinadas propiedades
o atributos y su comportamiento lo define métodos que actúan sobre
los datos. Las clases, se usa en otros programas al crear instancias de la
clase generando objetos que heredan sus características y métodos de la clase
padre. La programación orientada a objetos permite reutilizar las clases
creadas y organizadas como paquetes. Esta reutilización de clases evita
reinventar las clases y facilita la programación de java partiendo de un
conjunto de clases creadas por los diseñadores de java y de android con el fin
de ser utilizados en cualquier sistema operativo. En particular existen
paquetes de clases para los teléfonos inteligentes como el Samsung Galaxy mini
que tiene el sistema operativo android 2.2. A continuación se da una
lista de los principales paquetes estándar de java y de android.
java. awt
|
Contiene componentes para la interfaz de
usuario.
|
java.beans
|
Componentes para usar los beans de java.
|
java.io
|
Componentes para usar la entrada y salida de java.
|
java.lang
|
Es el paquete por defecto, contiene las clases principales de java.
|
java.math
|
Contiene funciones matemáticas, trigonométricas, logaritmos, raíz
cuadrada, etc.
|
java.net
|
Componentes para comunicaciones locales e internet.
|
java.rmi
|
Componentes para acceso remoto.en otra computadora.
|
java.security
|
Componentes que permiten mecanismos de seguridad.
|
java.sql
|
Permite la conectividad con bases de datos.
|
java.util
|
Diversos componentes de utilidad general.
|
java.swing
|
Componentes para la interfaz gráfica del usuario.
|
android.app
|
Contiene clases para encapsular el modelo de la aplicación android.
|
android.database
|
Contiene clases para explorar datos regresados del provedor de
contenido.
|
android.contains
|
Clases para explorar datos que regresan los provedores de contenido
|
android.database.sqlite
|
Contiene las clases del administrador de la base de datos SQLite
|
android.graphics
|
Es una herramienta grafica de bajo nivel como canvases, filtros de
color, puntos y rectángulos para dibujar la pantalla directamente.
|
android.media
|
Suministra las clases que manejan varios medios de interface de
audio y video.
|
android.net
|
Clases para acceso a una red más alla de los APIs de java.net.
|
android.os
|
Suministra los servicios de operación básicos, transferencia de
mensajes y comunicación de interprocesos.
|
android.telephony.
|
Suministro APIs para monitorear la información básica de un
telefóno, tal como el tipo de red y el estado de conexión, mas utilidades
para manipular las cadenas de un numero telefónico.
|
android.text
|
Suministra clases para render o rastrear texto y expander el texto
sobre la pantalla. android.util
|
android.util
|
Suministra métodos de utilería común tal como manipular fecha y
tiempo, codificadores y decodificadores de base 64, cadenas y conversión de
números y utilidades XML.
|
android.view
|
Suministra clases que expone clases básicas de la interface de
usuarios para manipular la pantalla y la interacción con el usuario.
|
android.widget
|
Contiene elementos de interface de usuario para ser usados en las
aplicaciones de la pantalla.
|
Interface
Grafica de Usuarios
Para usar la interface grafica de usuario en
sistemas operativos diferentes a android, java utiliza los paquetes de
awt y swing que contienen todos los componentes gráficos. Para usar la
interface gráfica de usuarios con android se utiliza el paquete de widget y
otros, que son diseñados específicamente para los teléfonos inteligentes o
móviles que tiene el sistema operativo android y contiene todos los componentes
gráficos como los layout o marcos, ventanas, vistas de texto, cuadros o
rectángulos de texto, botones, ventanas emergentes y de mensajes, etc. Por lo
tanto solamente algunos paquetes de java se pueden utilizar con android, como
los paquetes de entrada-salida o io, redes o net, utilería o útil y matemáticos
o math, entre otros. El programa modificado MainActivity del proyecto p01 de la pagina del blog anterior de Programación Android con AIDE y Java 1 es un ejemplo del uso de paquetes para desplegar un mensaje en la pantalla del teléfono y pueden checar como fue creado o editado(25), compilado(26,27 y 28) y ejecutado.(29, 30, y 31)
El programa MainActivity .java completo queda
como:
//Nombre del
paquete de este programa
package
com.gri.p01;
//La importación
de los paquetes que usa este programa
import
android.app.*;
import
android.os.*;
import
android.view.*;
import
android.widget.*;
//El nombre de la
clase MainActivity y una extensión de la clase activity
public class
MainActivity extends activity{
//Sobre posición de la clase onCreate para crear la pantalla
// y sus componentes gráficos
@Override
public void
onCreate(Bundle saveInstancesState{
super.onCreate(savedInstanceState);
//Comentar la siguiente instrucción para usar código java
//setContentView(R.layout.main);
//Crear una instancia objeto de layout
LinearLayout ll1 = new LinearLayout(this);
//Crear layout vertical
ll1.setOrientation(LinearLayout.VERTICAL);
//Crear una instancia objeto de textview
TextView tv1 = new TextView(this);
//Poner el mensaje
tv1.setText(“Hola…mi primer programa…”);
//Agregar la vista al layout
ll1.addView(tv1);
//Desplegar la pantalla completa del layout
setContentView(ll1);
}//oncreate
}//class
También en el
programa android anterior de MainActivity se puede crear el método main
para simular el main de java y queda de la siguiente forma.
MainActivity .java
//Nombre del
paquete de este programa
package
com.gri.p01;
//La importación
de los paquetes que usa este programa
import
android.app.*;
import
android.os.*;
import
android.view.*;
import
android.widget.*;
//El nombre de la
clase MainActivity y una extensión de la clase activity
public class
MainActivity extends activity{
//Sobre posición de la clase onCreate para crear la pantalla
// y sus componentes gráficos
@Override
public void
onCreate(Bundle saveInstancesState{
super.onCreate(savedInstanceState);
//Comentar la siguiente instrucción para usar código java
//setContentView(R.layout.main);
// Se crea el método main en android para simular el main de java
//pero sin parámetros de string y sus argumentos args de main(String[], args)
main();
}//oncreate
public void main{
//Crear una instancia objeto de layout
LinearLayout ll1 = new LinearLayout(this);
//Crear layout vertical
ll1.setOrientation(LinearLayout.VERTICAL);
//Crear una instancia objeto de textview
TextView tv1 = new TextView(this);
//Poner el mensaje
tv1.setText(“Hola…mi primer programa…”);
//Agregar la vista al layout
ll1.addView(tv1);
//Desplegar la pantalla completa del layout
setContentView(ll1);
}
}//class
Fundamentos
del Lenguaje Java
Para programar
android con java, es necesario estudiar los fundamentos de java y a
continuación explicaremos brevemente la sintaxis del lenguaje java, entendiendo
que todo programa de una computadora tiene instrucciones que manipulan datos.
Datos
Los datos
representan al mundo real de los números que son cantidades de diferentes
hechos que son enteros, decimales, booleanos de falso o verdadero y caracteres
Así como un conjunto de clases que forman una letra o palabras en forma de
cadenas, un conjunto de datos definidos como arreglos del mismo tipo de datos,.
Todos los datos pueden ser contantes o variables que son manipulados por las
instrucciones de un programa.
Variables
Las variables se
declaran, primero se pone el tipo y luego la variable o lista de variables y a
veces sus valores. Cada variable deberá tener un tipo. Los tipos pueden ser
primitivos como enteros, reales, booleano y como carácter o literal, de clases
como strings y arreglos.
Los nombres de las
variables deben de seguir las siguientes reglas.
1 El primer
carácter del nombre de ser una letra de a hasta z, de A hasta Z, el carácter _
y $
2 No puede usar el
nombre de palabras reservadas del lenguaje java.
3 El nombre debe
ser continuo, sin espacios intermedios.
4 Los nombres son
sensibles o diferentes con minúsculas y mayúsculas.
Tipos
primitivos
Los tipos
primitivos son los números enteros, números reales, booleanos y de
caracteres. Los enteros siempre tienen signo. Hay cuatro tipos de enteros. La
diferencia está en el tamaño que ocupan y el rango que pueden guardar.
Enteros
Los enteros
permiten contar cosas es decir asignar una secuencia numérica. Los enteros se
representan por un bit de 1 y 0, dos bits representan 4 combinaciones, en
general n bits representan 2 a la n combinaciones. Por ejemplo en 8 bits o un
byte se pueden representar 2 a la 8 combinaciones o sea 256 combinaciones, pero
la última posición de la izquierda representa el signo, por lo tanto se tiene 2
a la 7 para números positivos y negativos, es decir un rango de -128 a
127.
Bits
|
Entero +
|
Bits
|
Entero -
|
00000000
|
0
|
||
00000001
|
1
|
11111111
|
-1
|
00000010
|
2
|
11111110
|
-2
|
-----
|
-----
|
-----
|
-----
|
01111110
|
126
|
10000010
|
-126
|
01111111
|
127
|
10000001
|
-127
|
10000000
|
-128
|
También así se
tiene para los enteros de 2, 3 y 4 bytes.
Tipo
|
Tamaño en Bytes
|
Rango
|
byte
|
1
|
-128 a 127
|
short
|
2
|
-32,768 a 32,767
|
int
|
4
|
-2 a la 31 a 2 a la 31-1
|
long
|
8
|
-2 a la 63 a 2 a la 63-1
|
Reales
Los números reales
pueden almacenar números con parte decimal. Hay dos tipos de números reales. La
diferencia es la cantidad de decimales que pueden representar. Para representar
los reales o decimales de simple precisión se utilizan 4 bytes, una parte
para el exponente de valores + o - y la otra parte para la mantisa con
valores + o -. Para doble precisión se usan 8 bytes una parte para el
exponente con valores + o – y la otra parte para la mantisa con valores + o -.
+ o - Exponente
|
+ o - Mantisa
|
Tipo
|
Bytes
|
Nombre
|
Rango
|
float
|
4
|
Simple precisión
|
-3.4 x 10 a la 38 a -1.4 a la -45 x 10 a la -45
1.4 a la -45 x 10 a la -45 a 3.4 x 10 a la 38
|
double
|
8
|
Doble precisión
|
-1.8 x 10 a la 308 a -4.9 x 10 a la -324
4.9 x 10 a la -324 a 1.8 x 10 a la 308
|
Booleanos
El tipo boolean
representa variables que pueden tener uno de dos valores: true o false.
Caracter
El tipo char ocupa
1 byte para el código asci y de 2 bytes para el codigo Unicode.
Literales
Las literales son
caracteres especiales que controlan características en las declaraciones de
datos y son de string, carácter, enteras, reales y booleanas.
String
Las literales de
string se delimitan entre comillas dobles: "hola mundo". Si se desea
que el string tenga comillas dobles es necesario poner el carácter de escape
(\). "Alguien dijo: \"hola mundo\"".
Character
Las literales de
carácter se delimitan entre comillas sencillas: 'h', '$', '7'. Java maneja las
literales para caracteres no imprimibles como '\n' para el retorno de
carro y '\t' para el tabulador.
Enteras
Las literales
enteras se pueden especificar en base 10, por ejemplo 259, pero se pueden
especificar en base 8 colocando un cero antes, por ejemplo 064 o en base 16
poniendo 0x, por ejemplo 0xA9.
Reales
Las literales
reales se pueden escribir en formato normal, por ejemplo 5.953 o en formato
científico, por ejemplo 856.51E10 o 6.988E-2.
Booleanas
Las literales
booleanas son las palabras reservadas true y false.
Clases
Cuando se define
una clase se crea un nuevo tipo y se pueden declarar variables de ese tipo. Por
ejemplo, es posible declarar que una variable es de tipo String porque en la
librería estándar que ya está definida en una clase llamada String. También
existe la clase para manipular arreglos, pero lo más importante podemos crear
nuestras propias clases, como por ejemplo la clase de alumno con un nombre,
edad, grado, ect. Posteriormente veremos en una forma más detallada las clases
y objetos.
Strings
Pero ahora vamos a
ver en detalle la clase de String o cadena de caracteres, que es muy importante
para manipular datos de cadenas de caracteres. Para definir una variable de
strings se usa:
String
nombre-variable = new String(“nombre…”);
También se define
como:
String
nombre-variable = “nombre…”;
En la mayoría del
uso de clases de coloca new para poder crear un objeto, en el caso de los
strings no es necesario.
Concatenación de
strings
Consiste en unir
dos cadenas de caracteres cadena1 y cadena2 en una sola, con el operador
+.
String cadena1 =
“Cadena1”;
String cadena2 =
“Cadena2”;
String cadena3 =
cadena1 + cadena2 = Cadena1Cadena
También se puede
unir datos primitivos a una cadena.
int dato1 = 30;
String cadena3 =
cadena1 + cadena2 +dato1;
Arreglos
Un arreglo es una
clase y define una estructura de almacenamiento de un número determinado de
variables primitivas o de referencia a objetos, todas del mismo tipo, cada
elemento está identificado por un índice de 0 a n. En Java los arreglos se
declaran sin tamaño. Un arreglo se puede declarar como:
int arreglo[] o
como int [] arreglo;
Para poder usarlos
es necesario asignarles un tamaño. Se puede lograr esto dándoles valores
iníciales:
int arreglo[] =
{4, 2, 3, 10, 2};
También usando el
operado new se da su tamaño:
int
arreglo[]; arreglo = new int[10];
También se puede
definir en un solo paso:
int arreglo[] =
new int[10];
Los elementos de
un arreglo se accesan mediante un índice que puede valer entre 0 y t –
1, donde t es el tamaño del arreglo. Usando cualquiera de las
definiciones anteriores, las siguientes instrucciones son válidas.
Asignar un nuevo
valor al elemento de arreglo con índice 1:
arreglo[1] = 10;
Sumar el elemento
0 con otro valor constante de 10 al elemento del arreglo con índice 2:
arreglo[2] =
arreglo[0] + 10;
Incrementar el
elemento 5 de arreglo:
arreglo[5]++;
Arreglos de
strings: String nombres[] y nombres = new String[nombres];
Asignar al arreglo
nombres: String nombres[] = {“Pedro”, “María”, “Jesús”, “Rosa” , “Ana”};
Los arreglos
tienen asociada la variable length que indica el tamaño del arreglo. La
forma
de accesarla es nombre-del-arreglo.length.
En el caso del arreglo se puede usar así:
t =
arreglo.length;
Operadores
Un operador es
un símbolo especial que representa una operación y que se usa en una expresión
aritmética. Una expresión es una instrucción que obtiene un valor. Los
operadores son aritméticos, de asignación, comparación, lógicos, concatenación
y otros.
Operadores
aritméticos
Utiliza diferentes
operadores. El + para la suma, el – para la resta, el * para la multiplicación,
el '/' para la división y el '%' para el módulo. Si todos los operandos en una
expresión son enteros, la expresión regresa un entero. Con uno de los operandos
que sea real, el resultado es real. Así la división 2/3 se obtiene 0 y 2/3.0
regresa 0.6666.
Operadores
de asignación
Java tiene
diferentes operadores El símbolo = representa la asignación sencilla: a = 2;
Los símbolos ++ y
-- incrementan y decrementan en 1 el valor de la variable: a = 2; a++; // a
vale ahora 3
También existen
los operadores aritméticos con asignación como muestra a continuación:
Expresión
Significado
1) x += y es
equivalente a x = x + y
2) x -= y es
equivalente a x = x – y
3) x *= y es
equivalente a x = x * y
4) x /= y es
equivalente a x = x / y
Operadores
de comparación
Java tiene los
operadores de comparación: menor que (<), menor o igual que (<=), mayor
que (>), mayor o igual que (>=), igual que (==) y distinto que (!=).
Operadores
lógicos
AND(Y)
Java utiliza dos
símbolos para la operación AND (Y), el & y el &&. La diferencia es
que el operador & evalúa ambos lados de la expresión y el &&
puede que no evalúe la parte derecha si la parte izquierda es falsa (y por lo
tanto ya sabe que toda la expresión será falsa). A esto se le conoce como
evaluación en cortocircuito. El uso de uno u otro operador solo es relevante si
la parte derecha de la expresión tiene efectos laterales como una asignación.
Por ejemplo, si
tenemos este segmento de código:
int x = 2, a = 10;
if ((a < 0)
& (x++ > 0)){
instrucciones;
}
El operador &
evalúa la expresión de la izquierda (a < 0) y aunque es falsa evalúa la
parte derecha y por lo tanto incremente el valor de x a 3.
En cambio si
usamos el operador &&:
int x = 2, a = 10;
if ((a < 0)
&& (x++ > 0)){
instrucciones;
}
Al notar que la
expresión izquierda es falsa, la evaluación hace cortocircuito y no se evalúa
la parte derecha. Por lo tanto el valor de x se mantiene en 2. La mayor parte
de los autores recomienda usar el operador && y no poner asignaciones
en las condiciones.
OR(O)
Para la operación
OR (O) también hay 2 operadores, el | y el ||. Al igual que en el AND, el |
evalúa las dos partes de la expresión y el || no evalúa la parte derecha si la
parte izquierda es verdadera y por lo tanto sabe que toda la expresión es
verdadera.
XOR(O
Exclusivo)
Para la operación
XOR (OR exclusivo) el operador es el ^.
NOT(No)
Para la operación
NOT (no) el operador es el !.
Operador (?
:)
El operador ? :
funciona de la siguiente forma. La expresión:
(x> 0 ? –1 : 1)
Toma el valor –1
si x es mayor que 0 o 1 si x es menor o igual que 0.
Operador
instanceof
El operador
instanceof sirve para preguntar si una variable es o no de un tipo en
particular.
El operador
regresa verdadero o falso según el caso.
int x;
x instanceof int
// regresa verdadero
x instanceof
double // regresa falso
Operador
new
El operador new
crea nuevas instancias de clases. Posteriormente se verá en detalle.
Expresiones
Una expresión es
una instrucción matemática que calcula un valor y se asigna a una variable. Se
construyen al combinar operandos como constantes y variables con los operadores
que actúan sobre ellas. En expresiones complejas se utilizan paréntesis para
indicar el orden de evaluación. El paréntesis agrupa operaciones, primero se
realizan los paréntesis, después multiplicaciones y divisiones, y por último
sumas y restas. Ver tabla de precedencia.
Ejemplo: A la
variable var1 se asigna el resultado de calcular la expresión de la derecha
Var1 =
((x+22)*(789*y))/(123+z)
La tabla siguiente muestra la
precedencia asignada a los operadores, éstos son listados en orden de
precedencia. Los operadores en la misma fila tienen igual precedencia y se
realizan de izquierda a derecha.
Operador
|
Notas
|
. [] ()
|
Los corchetes se
utilizan para los arreglos
|
++ --
! ~
|
! es el NOT
lógico y ~ es el complemento de bits
|
new (tipo)expr
|
new se utiliza
para crear instancias de clases
|
* /
%
|
Multiplicativos
|
+ -
|
Aditivos
|
<<
>> >>>
|
Corrimiento de
bits
|
< >
<= >=
|
Relacionales
|
== !=
|
Igualdad
|
&
|
AND (entre bits)
|
^
|
OR exclusivo
(entre bits)
|
|
|
OR inclusivo
(entre bits)
|
&&
|
AND lógico
|
||
|
OR lógico
|
? : ;
|
Condicional
|
= +=
-= *= /= %= &= ^= |=
<<= >>= >>>=
|
Asignación
|
Todos los operadores binarios que
tienen la misma prioridad (excepto los operadores de asignación) son evaluados
de izquierda a derecha. Los operadores de asignación son evaluados de derecha a
izquierda.
Ejemplo. La
siguiente formula da la media aritmética de cinco términos:
Algebra: m =
a + b + c + d + e / 5
Java: m = ( a +
b + c + d + e ) / 5;
Los paréntesis son
requeridos, la división tiene mayor precedencia que la suma. Todos los cinco
términos entre paréntesis son primero sumados y al final se realiza la
división.
Ejemplo. La
siguiente formula representa una línea recta.
Algebra: y = mx +
b
Java: y = m * x
+ b;
Los paréntesis no
son requeridos, la multiplicación se realiza primero y después la suma y el
asignamiento el resultado al final.
Ejemplo. Considere
la siguiente ecuación de segundo grado.
Algebra (y
= ax2 + bx + c):
Java
y = a * x * x + b * x + c;
6 1 2 4
3 5
Los números
indican la secuencia de evaluación.
Para más claridad
se pueden colocar paréntesis, pero resulta redundante.
y = ( a * x
* x ) + ( b * x ) + c;
Instrucciones
Todo programa de
una computadora se ejecuta como una secuencia de instrucciones, como la
instrucción que evalúa expresiones que manipulan datos con operaciones
matemáticas o lógicas, o de instrucciones de entrada o salida, pero las
instrucciones de control y decisión pueden alterar la secuencia de ejecución.
Las instrucciones de java van separadas por punto y coma. Los bloques de
instrucciones se agrupan con corchetes que contienen instrucciones
{instrucciones}. Aquí un breve repaso de la sintaxis de cada una de las
instrucciones principales.
Comentarios
Cuando un
comentario ocupa varias líneas se puede delimitar usando los símbolos /*
instrucciones comentadas*/. Para una línea se usa el símbolo // para indicar al
compilador que ignore lo que sigue hasta el fin de línea.
Instrucción
if
Cambia la
secuencia de ejecución de las instrucciones del programa cuando se cumpla una o
varias condiciones.
Sintaxis:
if (condición){
instrucciónes;
}
La condición se
evalúa, si es verdadera se ejecuta la instrucción, si es falsa continúa con la
siguiente instrucción.
La palabra
reservada else sirve para ejecutar una instrucción alterna si la condición es
falsa.
Sintaxis:
if
(condición){instrucciónes1;
}else{
instrucciónes2;
}
La condición se
evalúa, si es verdadera se ejecuta las instrucciónes1, si es falsa se ejecuta
la
instrucciónes2.
El segmento de
código siguiente muestra el uso de un if para decidir si un número entero es
par o impar.
TextView tv1
= new TextView(this); // Android
if ((n % 2) == 0){
System.out.println
(n + " es par"); //En java
tv1.setText(n+”Es
par”); // En android
}else{
System.out.println
(n + " es impar"); //En java
tv1.setText(n+”Es
impar”); // En android
}
Instrucción
for
Repite una
secuencia de instrucciones hasta que se cumpla una o varias condiciones.
Sintaxis:
for (inicio;
condición; postcondición){
instrucciones;
}
El flujo de
control es el siguiente:
1) Se evalúa la
expresión de inicio
2) Se evalúa la
condición
3) Si la condición
es falsa el ciclo termina.
4) Si es verdadera
ejecuta la instrucción (que puede ser un bloque de instrucciones encerrado
entre corchetes), evalúa la postcondición y regresa al paso 2.
Ejemplo: El código
imprime 10 veces el letrero Hola mundo… en la pantalla:
TextView tv1
= new TextView(this); // Android
for (i = 0; i <
20; i++){
System.out.println
("Hola mundo…"); //En java
tv1.setText(“Hola
mundo…”); // En android
}
Instrucción
while
Repite una
secuencia de instrucciones hasta que se cumpla una o varias condiciones.
Sintaxis:
while (condición){
instrucciónes;
}
La instrucción se
ejecuta mientras la condición sea verdadera.
Ejemplo: El código
muestra el uso de un while para escribir el índice del primer elemento negativo
de un arreglo o un mensaje de error si no existe ninguno.
int arrayx[] =
{...};
int i = 0;
boolean ok =
false;
TextView tv1
= new TextView(this); // Android
while (!ok
&& (i < arrayx.length)){
if
(arrayx[i] < 0){
ok = true;
}else{
i++;
if (ok){
System.out.println
("El primer número negativo esta en" + i); //En java
tv1.setText(“El
primer número negativo esta en: ”+i); // En android
}else{
System.out.println
("No existe ningún numero negativo"); //En java
tv1.setText(“No
hay un número negativo: ”); // En android
}
}
}
Instrucción
do while
Repite una
secuencia de instrucciones hasta que se cumpla una o varias condiciones.
Sintaxis:
do {
instrucciónes;
} while
(condición);
La instrucción se
ejecuta mientras la condición sea verdadera. La diferencia con el ciclo while
es que el do while primero ejecuta la instrucción y luego revisa la condición.
Por lo tanto el do while siempre se hace por lo menos una vez.
Ejemplo: El código
también imprime 5 veces el mensaje en la pantalla:
TextView tv1
= new TextView(this); // Android
i = 0;
do {
System.out.println
("Hola mundo…"); //En java
tv1.setText(“Hola
mundo…”); // En android
i++;
} while (i <
5);
Instrucción
switch
Sustituye a varios
ifs y repite una secuencia de instrucciones cuando se cumpla una o varias
condiciones.
Sintaxis
switch (expresión)
{
case valor
1 : instrucciónes1;
case valor
2 : instrucciónes2;
...
[default :
instrucción n;] // El corchete cuadrado indica que es opcional
}
La expresión se
evalúa y se compara con cada uno de los valores de la parte case. Si encuentra
una coincidencia ejecuta las instrucciones a partir de ese caso. Si no
encuentra ninguna coincidencia ejecuta la instrucción correspondiente a la
parte default si es que está presente o continua con la siguiente instrucción
al switch si no hay default. Se puede indicar que solo ejecute un caso usando
la instrucción break.
Ejemplo: El
código, dado de un número entero que representa el mes (1 es enero, 2 es
febrero, ..., 12 es diciembre) asigna en la variable día el número de
días del mes o –1 si el número de mes está fuera de rango.
switch (mes) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
dia = 31;
break;
case 4:
case 6:
case 9:
case 11:
dia = 30;
break;
case 2: dia
= 28;
break;
default:
dia = -1;
}
Instrucción
return
La instrucción
return sirve para salir de un método o de una instrucción de control o
decisión. Si el método regresa un valor el return que va seguido de una
expresión que se convertirá en el valor del método.
Ejemplos del uso
del return.
Instrucción
break
La instrucción
break sirve para salir de un switch. El break también se puede utilizar para
terminar un ciclo for, while o do while como en el ejemplo siguiente que
escribe 5 veces
el letrero
"Hola mundo" en la pantalla:
int i = 0;
TextView tv1
= new TextView(this); // Android
while (true) {
System.out.println
("Hola mundo…"); //En java
tv1.setText(“Hola
mundo…”); // En android
i++;
if (i ==
5){
break;
}
}
Si el ciclo está
anidado dentro de otro ciclo, la ejecución continúa con el ciclo externo.
Instrucción
continue
La instrucción
continue suspende la ejecución de un ciclo y continúa con la siguiente
iteración.
Ejemplo: El código
muestra el uso del continue dentro de un ciclo para contar los elementos
positivos de un arreglo.
int cuenta = 0;
TextView tv1
= new TextView(this); // Android
for (int i = 0; i
< vector.length; i++) {
if
(vector[i] < 0){
continue;
}
cuenta++;
}
System.out.println
("El arreglo tiene " + cuenta + "elementos positivos");
//En java
tv1.setText(“El
arreglo tiene: ”+ cuenta + “Elementos positivos”); // En android
Todo lo visto
forma parte de todo programa básico de una computadora que define datos y son
manipulados por las instrucciones de los métodos del programa. Ahora trataremos
temas avanzados que también pueden ser programados en android con AIDE y Java.
Clases y
Objetos
Un programa en
java orientado a objetos está definido por una clase o varias que pueden
crear instancias como objetos y contienen datos con determinadas características
o atributos y su comportamiento lo crean los métodos de la clase. Como hemos
visto las clases que han sido diseñadas para java y android se pueden
reutilizar posteriormente y evitar volver reinventar las diferentes clases que
conforman todo el sistema del lenguaje java y android. Un lenguaje de
programación orientado a objetos tiene las características de abstracción,
encapsulado, herencia y la invalidación. La abstracción hace referencia a una
clase general donde se obtiene subclases que contiene características de la
clase padre y características propias de cada subclase. El encapsulado se
refiere a la protección y acceso de las clases de sus datos y procedimientos
por otros programas. Así tenemos el público o public que cualquier otro
programa de cualquier paquete puede compartir, El privado o private que
solamente la propia clase y sus métodos pueden compartir. El
protegido o protected donde solamente las clases hijos pueden
compartir características de su padre. El paquete de java permite organizar las
clases en un determinado tipo y de forma jerárquica, facilitando la
reutilización de las clases. La herencia de las clases permite heredar
características de los atributos y de sus métodos. La herencia en java es
simple es decir solo de padre a hijos, pues también existe la herencia múltiple
como en otros lenguajes. Para solucionar el problema de herencia múltiple, java
utiliza las interfaces, que permite compartir diferentes clases. La
invalidación se refiere a la extensión de las clases padre a sus descendientes,
así las subclases o hijas puede sobreponerse y crear extensiones en sus datos y
métodos a la de la superclase o clase padre. Como programadores podemos diseñar
nuestras propias clases y poder utilizarlas posteriormente en paquetes. Todo lo
que trataremos en adelante se relacionan con las clases creadas por los
diseñadores de java y android, pero las utilizaremos directamente o creando
extensiones de ellas.
Las instrucciones de entrada-salida nos permiten comunicarnos al exterior del teléfono inteligente. Las instrucciones de entrada-salida estándar de java no pueden aplicarse en android, ya que este utiliza componentes gráficos. Para la entrada de datos utilizamos un teclado o la pantalla del teléfono que incluye en la misma pantalla un teclado. En android utilizamos un cuadro para capturar los datos, al instanciar un objeto de la clase EditText. Para la salida utilizamos la pantalla del teléfono al crear una instancia del objeto de la clase TextView. También podemos leer datos y escribir o grabar datos de archivos y de bases de datos que están en un disco duro o en una memoria permanente interna o también en una memoria externa permanente como la de un microSD. En los proyectos de la página anterior ya hemos utilizado las clases de Edit Text y TextView.
Hasta ahora hemos visto datos estáticos, pero también existen estructuras de datos dinámicos que crecen y se reducen en la memoria al ejecutarse el programa. Hay diferentes estructuras de datos y las más conocidas son las listas de arreglos, listas enlazadas, pilas, colas y arboles binarios. La lista de un arreglo son elementos consecutivos que pueden agregarse, eliminarse, cambiarse y clasificarse. Las listas enlazadas son colección de datos alineados en una fila, agregarse, eliminarse, cambiarse y clasificarse los elementos de la lista. Las pilas son importantes en los compiladores para evaluar expresiones y en los sistemas operativos para administrar la memoria, se pueden insertar elementos y se pueden extraer, para ambos casos de la parte superior de la pila. Las colas se usan en modelos de línea de espera, donde se calculan los tiempos que se tiene que esperar para ser atendido en un servicio, se insertan elementos en el final de la cola y se sacan al principio de la cola. Los arboles binarios facilitan la ordenación y búsqueda de elementos de forma muy rápida, también se usan en la administración del sistema de directorios y de archivos del sistema operativo. Para utilizar las estructuras de datos un programa debe importar el paquete de java.util. Es muy importante saber que con estas estructuras de datos los valores asignados a las estructuras se pierden cuando el programa finaliza. Para conservar los datos cuando termine el programa se utilizan los archivos y bases de datos.
Archivos de Datos
Los archivos están organizados como registros y campos de datos, y pueden ser generados y recuperados de forma secuencial o al azar. Los archivos son el medio por el cual los datos son almacenados y pueden utilizarse por cualquier programa con solo seleccionar el archivo deseado, abrirlo y utilizarlo para leerse, actualizarse, eliminar el archivo completo o solo un registro y agregarse nuevos registros. Para manipular los directorios, archivos y campo de datos, android utiliza el paquete de java.io. Para seguridad de los datos es necesario hacer respaldos de ellos de forma periódica para el caso de falla del teléfono, incluyendo la memoria interna permanente o el disco duro. Para crear aplicaciones donde los archivos tienen gran cantidad de datos y que relacionan a los archivos por medio de campos de datos se utilizan las bases de datos relacionales.
Base de Datos
Las bases de datos facilitan la manipulación de los archivos de datos, pero están organizados como tablas o archivos, renglón o registro y columnas o campos de datos. La ventaja de las bases de datos es que varios archivos están contenidos en un solo archivo grande que se llama base de datos, esto facilita la manipulación de los datos controlados por un programa gestor de la base de datos, que permite el acceso controlado de los usuarios y además se puede respaldar la base de datos previniendo corrupción o perdida de los datos. Android tiene integrado en su sistema la base de datos SQLite para las aplicaciones que requieran el uso de una base de datos, pero es necesario importar el paquete de android.sqlite. Esta base de datos de SQLite se usa en aplicaciones locales en el propio teléfono inteligente. Para utilizar una base de datos que está en otra computadora local o remota los teléfonos inteligentes utilizan las redes de comunicación.
Comunicación en Redes Locales y Remotas
Las comunicaciones de datos se pueden realizar en redes locales o en redes amplias o remotas. Una red local incluye a computadoras en un edificio o en edificios cercanos. Para redes amplias se utiliza una computadora con una interface a una comunicación global como internet. Para conectar un teléfono a una red local o amplia debe usar el protocolo wi-fi permitiendo de esta forma conectarse a otra computadora por internet. Uno de los principales usos las redes locales y remotas del teléfono inteligente es el acceso a bases de datos remotas para diferentes servicios. Para los programas que utilicen los servicios de redes deben importar el paquete de java.net y android.net. Pero también el teléfono inteligente utiliza la red de comunicación telefónica que puede utilizar los servicios de telefonía celular y de mensajería sms, y también de internet.
Comunicación Telefónica
La comunicación telefónica en los teléfonos inteligentes es la parte más importante y se han desarrollado en diversas generaciones de sistemas telefónicos y es la parte más complicada de programación que veremos posteriormente.
Primera generación 1G. Surge en los años de 1980, las señales de comunicación son analógicas y por lo tanto solo puede comunicar voz. Se introdujo la utilización de múltiples celdas representadas por torres de comunicación, distribuidas en una determinada área de una ciudad y se inicio la transferencia automática entre las torres de comunicación de la conversación, mientras el usuario se desplazaba en diferentes celdas. La comunicación era muy susceptible al ruido y se perdía fácilmente, así como baja calidad de la voz. El sistema más importante fue el AMPS o Adavanced Mobile Phone System o Sistema avanzado de telefonía móvil.
Segunda Generación 2G. Se inicio la globalización digital en la telefonía, se redujo el tamaño del teléfono celular y una conexión más rápida, se incremento la seguridad y calidad de la voz. Se inicio la comunicación de mensajes de textos SMS Short Message Service, inicialmente este servicio fue en el GMS Global System for Movil Communications o Sistema Móvil Global y es el sistema de comunicación más importante de la segunda generación, con más de 3 billones de usuarios en 200 países.
Tercera Generación 3G. Antes de esta generación se realizaron mejoras a la 2G creando las generaciones de 2.5G y 2.75G culminando en grandes mejoras en la comunicación de datos y voz en un solo canal o una video conferencia, descarga de datos como programas y archivos, correo electrónico, mensajería instantánea, todo a una velocidad de 384 Kbxs. La 3G aparece como la mejor opción para conexiones por internet a gran velocidad y seguridad. Lo más importante es la compatibilidad de comunicación a nivel mundial y la coexistencia con redes de 2G.
Cuarta Generación 4G. Esta generación es la comunicación del futuro e integrará las comunicaciones telefónicas con internet al utiliza el protocolo IP o Internet Protocol dando facilidad y poder de computación y comunicaciones a los teléfonos inteligentes. La velocidad de transferencias será mayor de 1 Gbxs y con un gran ancho de banda para beneficio de la televisión High Definition o alta definición en tiempo real.
Resumen
Hemos tratado en detalle los fundamentos del lenguaje java orientado a objetos de los diferentes datos que son manipulados por las instrucciones de los métodos de un programa en java y en forma general de los temas avanzados de las estructuras de datos, archivos de datos, bases de datos y las redes locales y remotas, así como las comunicaciones telefónicas, todos esos temas se trataran en detalle después. En las próximas páginas del blog crearemos programas que utilizan todo lo visto aquí.
