Vistas de página en total

miércoles, 20 de junio de 2012

Programación Android con AIDE y Java 2


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)
Este programa utiliza los paquetes de android app, os y el widget para la interface gráfica de usuario, para usar el layout o marco de la pantalla y la vista de texto para desplegar “Hola…mi primer programa”. Las dos diagonales // significan comentarios dentro del programa.
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. 
Instrucciones de Entrada y Salida
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.
Estructuras de Datos
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í.       
       

No hay comentarios: