AndroidIntro1: Repaso de Java. Android: Introducción a la Programación

Unidad 1 : Repaso de Java

Introducción

Aunque existen otras alternativas, la gran mayoría de aplicaciones Android se desarrollan utilizando el lenguaje Java. La elección de este lenguaje no ha sido arbitraria, como veremos en el siguiente apartado, Java tiene una serie de características que lo hacen especialmente interesante para el sistema Android.

Por lo tanto, disponer de conocimientos sobre este lenguaje de programación es importante para un desarrollo adecuado del curso. Si nunca has trabajado con Java, no te preocupes, Java es un lenguaje sencillo y para seguir el curso no va a ser imprescindible un dominio del mismo (con entender el código será suficiente). Eso sí, vas a necesitar nociones de programación, especialmente es interesante que conozcas la sintaxis de lenguajes como C o C++, o haber trabajado con algún lenguaje orientado a objeto. Si no tienes conocimientos de programación tendrás muchos problemas en seguir el curso.  

Conocer las características principales de Java.
Tener una primera toma de contacto con el lenguaje y familiarizarse con la sintaxis de Java.
Para aquellos que ya conocen el lenguaje, repasar los conceptos fundamentales.
Repasar los aspectos más importantes de la Programación Orientada a Objeto.
Usar tipos enumerados en Java.
Aprender las posibilidades que nos ofrecen las colecciones en Java.

Características de Java https://youtu.be/Mmmrp8PRLOo
    Enumerar las características del lenguaje de programación Java https://youtu.be/Mmmrp8PRLOo
    Resaltar sus ventajas e inconvenientes
    http://www.dcomg.upv.es/~jtomas/android/unidad_0/Caracter%C3%ADsticas%20...
    Ampliar información en el capítulo 1 del libro Piensa en Java de Bruce Eckel.
    Piensa en Java: http://www.etnassoft.com/biblioteca/piensa-en-java-edicion-espanola/

El compilador JIT (Just-In-Time) es un componente de Java™ Runtime Environment que mejora el rendimiento de aplicaciones Java en tiempo de ejecución. https://www.ibm.com/support/knowledgecenter/es/SSYKE2_7.0.0/com.ibm.java...
El compilador JIT https://www.ibm.com/support/knowledgecenter/es/SSYKE2_7.0.0/com.ibm.java...

 

 

 ---------------------------------
Instalación del entorno de desarrollo  
Alternativas para intalar un entorno de desarrollo para Java y Android.

Google ha preparado el paquete de software Android SDK, que incorpora todas las herramientas necesarias para el desarrollo de aplicaciones en Android. En él se incluye: conversor de código, depurador, librerías, emuladores, documentación, ejemplos de código, etc. Todas estas herramientas son accesibles desde la línea de comandos.

No obstante, la mayoría de los desarrolladores prefieren utilizar un IDE (entorno de desarrollo integrado). Un IDE agrupa, en un entorno visual, un editor de código con todas las herramientas de desarrollo. Google recomienda utilizar Android Studio (basado en el IDE IntelliJ IDEA).

Instalación de la máquina virtual Java

Las aplicaciones Android están escritas en Java, por lo que necesitas instalar un software para ejecutar código Java en tu equipo. Este software se conoce como máquina virtual Java, entorno de ejecución Java, Java Runtime Environment (JRE) o Java Virtual Machine (JVM).

Es muy posible que ya tengas instalada la máquina virtual Java en tu equipo. Si es así, puedes pasar directamente a uno de los apartados siguientes. En caso de dudas, puedes pasar también al punto siguiente. Al concluirlo te indicará si la versión de la máquina virtual Java es incorrecta. En caso necesario, regresa a este punto para instalar una que sea adecuada.

Para instalar la máquina virtual Java accede a http://www.java.com/es/download/, descarga e instala el fichero correspondiente a tu sistema operativo.
Instalación de Android Studio

En la edición de Google I/O 2014 se lanzó la primera versión estable de Android Studio. Se trata de un nuevo entorno de desarrollo para Android basado en el IDE IntelliJ IDEA. Entre las novedades introducidas destacamos:

-        Construcción de proyectos usando la herramienta Gradle.
-        Previsualización simultána de un layout en varios tipos de dispositivos.
-        Facilidades para el testeo de código basado en JUnit.
-        Importación de ejemplos de código desde GitHub.
·       Integración con herramientas de gestión de versiones (como GitHub).
·       Desarrollo en un mismo proyecto de diferentes versiones (como Android Wear, Android TV y Android Auto)

Ejercicio: Instalación de Android Studio

1.      Descarga el paquete correspondiente a tu versión de la siguiente dirección:
http://developer.android.com/sdk/
2.      Ejecuta el fichero obtenido en el paso anterior:
3.      Selecciona todos los componentes a instalar y pulsa Next.
4.      Acepta el contrato de licencia y selecciona las carpetas donde quieres instalar el IDE Android Studio y el SDK. En el resto de ventanas puedes utilizar las opciones por defecto. En la última ventana indica que quieres arrancar Android Studio.
5.      Primero te preguntará si quieres importar la configuración desde una instalación anterior. Luego verificará si hay actualizaciones del SDK.
6.      Tras pulsar en Finish pasamos a la ventana de bienvenida:
7.      Comienza pulsando en Configure. Apareceran varias opciones, selecciona SDK Manager. Esta herramienta es de gran utilidad para verificar si existen actualizaciónes del SDK o nuevas versiones de la plataforma. Podrás acceder a ella desde la ventana principal de Android Studio pulsando en el botón SDK Manager:
8.      Al entrar en el SDK Manager te muestra los paquetes instalados y los que puedes instalar o actualizar:
En la lengüeta SDK Plataforms se muestran los paquetes de plataforma. Pulsa en Show Package Details para ver los diferentes paquetes. Siempre es conveniente que tengas instalados los siguientes paquetes de la última plataforma disponible:

Android SDK Platform X (donde X es la última versión disponible)
Sources for Android X (no es imprescindible)
Google APIs … System Image (para crear emuladores con Google APIs)
Google Play … System Image (para crear emuladores con Google APIs + Google Play)

En la lengüeta SDK Tools se muestran paquetes con herramientas de la plataforma. Siempre es conveniente que tengas actualizados los siguientes paquetes:
    Android SDK Build-Tools
    Android SDK Platform-tools
    Android SDK Tools
    Google Play services
    Support Repository

Recursos adicionales: Teclas de acceso rápido en Android Studio
Alt-Intro: Solución rápida (Ej. añade imports de las clases no resueltas).
Shift-F10:  (Ctrl-R en Mac): Ejecuta el proyecto.
Shift-F9:  (Ctrl-D en Mac): Depura el proyecto.
Shift-F6: Cambia el nombre de un identificador.
Ctrl-Alt-L (Option-Cmd-L en Mac): Formatea automáticamente el código.
Ctrl-Q (F1 en Mac): Muestra documentación del código.
Ctrl-P: Muestra parámetros del método seleccionado.
F4 (Cmd-fecha abajo en Mac): Salta a declaración.
Ctrl-Y (Cmd-Espacio en Mac): Borra línea.
Alt-Insert (Cmd-N en Mac): Inserta método

Enlaces de interes: Conoce Android Studio
https://developer.android.com/studio/intro/index.html?hl=es-419
Preguntas de repaso: Instalación y entorno de desarrollo
http://mmoviles.upv.es/test_fundamentos/examen.php?s=0_2%20Instalacion%2...

 

 

Creación de clases en Java https://youtu.be/yIeHtnwTN_M
Definir los términos objeto y clase. Describir la forma en que podemos crear nuevas clases en Java.

Creación y utilización de objetos  
Java es un lenguaje orientado a objetos, donde casi todo se realiza utilizando objetos. Por lo tanto va a resultar vital conocer cómo definir clases de objetos de Java.
Antes conviene definir estos términos:
Objeto: entidad que dispone de unas propiedades (atributos) y comportamiento (métodos).
Clase: define un tipo de objeto concreto.
Por ejemplo, si quisiéramos escribir un programa en Java para gestionar los libros de una biblioteca, crearíamos la clase Libro, y luego un objeto de esta clase, por cada libro que tengamos en la biblioteca.

Una clase en Java está formada por:
    Atributos: (o campos/propiedades) Almacenan algún tipo de información del objeto. Definen su estado.
    Constructor(es): Método que se utiliza para inicializar un objeto.
    Métodos: Son utilizados para modificar o consultar el estado de un objeto. Equivalentes a las funciones o procedimientos de otros lenguajes.

NOTA: En Java solo hay dos excepciones al uso de objetos, además de estos podemos utilizar variables simples y arrays. La forma de hacerlo es muy similar a como lo haríamos en C o C++. En la siguiente tabla se muestra una tabla con los tipos simples disponibles en Java.

Para crear una nueva clase, lo primero que tienes que hacer es crear un fichero que ha de llamarse exactamente igual que la clase y con extensión .java. Recuerda, siempre un fichero por clase.

Al principio de este fichero se suele indicar el paquete al que pertenecerá esta clase. Por ejemplo:

    package org.upv.cursoandroid.unidad0;

seguido de otros paquetes definidos previamente que queremos utilizar:

    import android.app.Activity;
    import android.content.BroadcastReceiver;
    import …

Cómo las clases son agrupadas en paquetes será explicado más tarde. De momento no es imprescindible para trabajar con los primeros ejemplos.

Para declarar una clase sigue el siguiente esquema:

    class <clase>  {
       //declaración de atributos
      [visibilidad] [modificadores] <tipo> <atributo> [= valor];
      ...
      //declaración de constructor
      public <clase>(<argumentos>) {
        <instrucciones>;
      }
      //declaración de métodos
      [visibilidad] [modificadores] <tipo> <método>(<argumentos>) {
        <instrucciones>;
      }
      ...
    }

donde:

    [visibilidad] = public, protected o private
    [modificadores] = final, static y abstract

El significado de estas palabras se explica más adelante.

Una clase comienza por la palabra reservada class seguida del nombre de la clase. Por convenio los nombres con la inicial mayúsculas. Si queremos usar varias palabras, las concatenamos sin espacios con las iniciales en mayúscula. A continuación se definen los atributos, seguido del constructor/es y de la declaración de métodos.

Un ejemplo de una clase se muestra a continuación:

    /** Clase que representa un número complejo. */
     class Complejo {
      //declaración de atributos
      private double real, imaginario;
      //declaración de constructor
      public Complejo(double real, double imaginario) {
        this.real= real;
        this.imaginario= imaginario;
      }
      //declaración de métodos
      /** Transcribe el complejo a String.
       * @returnun string con la parte entera y la imaginaria
       */
      public String toString() {
        return real + "+"+ imaginario + "i";
      }
      /** Suma al complejo de este objeto otro complejo.
       * @param v  el complejo que sumamos
       */
      public void suma(Complejo v) {
        real = real + v.real;
        imaginario = imaginario + v.imaginario;
      }
    }

Una clase necesita almacenar algún tipo de información que defina el objeto en cuestión. Esto se hará en los atributos o campos de la clase. En el ejemplo queremos representar un número complejo, y por lo tanto vamos a necesitar almacenar la parte real y la parte imaginaria del número.

El siguiente paso suele ser declarar el constructor. Un constructor es un método que tiene el mismo nombre de la clase y que se utiliza para inicializar un objeto. Tiene una serie de parámetros separados por comas, en nuestro ejemplo, la parte real y la parte imaginaria del número complejo. El código de este método (las instrucciones entre {…} ) se limita a copiar estos valores en los atributos del objeto. Aunque aquí aparece un problema, los parámetros del método (real, imaginario) y los atributos de la clase (real, imaginario) se llaman igual. Para resolverlo podemos anteponer a los atributos la palabra reservada this. De esta forma indicamos que nos referimos a los atributos del objeto.

Para terminar declaramos los métodos de la clase. Los métodos son equivalentes a las funciones o procedimientos de otros lenguajes y son utilizados para modificar o consultar el estado de nuestro objeto.

Los métodos suelen comenzar indicando su visibilidad (public,protected o private). El significado de cada una de estas palabras se explica más adelante. A continuación los métodos indican el tipo de datos que devuelven. En el ejemplo el primer método devuelve un String y el segundo void, o lo que es lo mismo nada. Luego sigue el nombre del método y los parámetros. Dentro del primer método se utiliza la palabra reservada return para indicar el valor devuelto por el método.

Creación y utilización de objetos:   Mostrar cómo una vez creada una clase podemos crear objetos de esta clase y utilizarlos.

Para crear varios objetos de la clase anterior podemos utilizar la siguiente clase:

    package com.example.complejos;
    class Principal {
        public static void main(String[] main) {
            Complejo z, w;
            z = new Complejo(-1.5, 3.0);
            w = new Complejo(-1.2, 2.4);
            z.suma(w);
            System.out.println("Complejo: " + z.toString());
        }
    }

La clase Principal es algo atípica, no tiene atributos ni constructor, únicamente el método main. Cuando en un proyecto existe una clase que tiene un método con este perfil, es el que se llama para comenzar la ejecución. Como parámetros este método recibe un array de Strings. Esta información tiene interés cuando el programa es ejecutado desde la línea de comandos con parámetros.

El la primera línea se declaran los objetos z y w. En las dos siguientes líneas se inicializan los objetos llamando al constructor. Se utiliza la expresión:

<objeto> = new <Clase>(<parámetros>);.

También es posible declarar e inicializar el objeto en la misma sentencia de la siguiente forma:

<Clase> <objeto> = new <Clase>(<parámetros>);

En el ejemplo sería:

Complejo z = new Complejo(-1.5, 3.0);

Siguiendo con el ejemplo en la siguiente línea se llama a un método suma() del objeto z. Se sigue el siguiente expresión:

<objeto>.<método>(<parámetros>);

En la última línea utilizamos System.out.println() para sacar por la consola una cadena de caracteres. Es decir, si ejecutamos la aplicación desde una consola de la línea de comandos se mostrará un mensaje por pantalla.  

Ejercicio paso a paso: Creación de una primera clase

Android Studio está pensado exclusivamente para crear aplicaciones Android. Sin embargo, si sigues los siguientes pasos podrás crear una aplicación 100% Java:

1.     Arranca Android Studio.

2.     Crea un nuevo proyecto (File> New > New Project..) con nombre de aplicación Complejos y nombre de paquete com.example.complejos. En la segunda ventana marca Phone and Tablet. Y en la tercera selecciona la opción Add No Activity, así no creamos una actividad que nunca será usada. Pulsa Finish.

3.     Pulsa en File> New > New Module. Selecciona Java Library y pulsa Next.

4.     Introduce en Library name: complejos, como Java pakage name: com.example.complejos y en Java class name: Complejo. Pulsa el botón Finish. Se creará un nuevo módulo Java dentro de tu proyecto Android.

5.     Abre el explorador del proyecto (pestaña 1: Projet o <Alt-1>). Despliega el paquete complejos y busca dentro la clase Complejo.  Reemplaza su código por el mostrado anteriormente en el ejemplo de la clase Complejo. (Código de complejo ubicado en la unidad anterior). Has de dejar la primera línea package com.example.complejos;

6.     En el explorador del proyecto, pulsa con el botón derecho sobre complejos / java / com.example.complejos  y selecciona New / Java Class.

7.     Introduce en el campo Name: Principal y pulsa en Finish.

8.     Reemplaza el código por el mostrado anteriormente en el ejemplo de la clase Principal.

9.   Pulsa en el botón desplegable a la derecha del botón Run  . Selecciona Edit Configurations...

10.  En la nueva ventana, haz clic en el signo + de la esquina superior izquierda y selecciona Application. Aparecerá una nueva configuración de aplicación. Selecciona en Name: complejos, en Main class: com.example.complejos.Principal y en Use classpath of module: complejos. Pulsa en OK..

11.  Pulsa el botón Ejecución y verifica que el resultado que aparece en la ventana de Run es similar a:
"C:\Program ...
Complejo: -2.7+5.4i
 
Process finished with exit code 0

12.    En la clase Principal reemplaza "Complejo: " + z.toString() por "Complejo: " + z. Ejecuta de nuevo el proyecto y observa que el resultado no cambia. En Java si añadimos cualquier objeto a una expresión de texto, se utilizará el método toString()  para convertir el objeto a texto.
Practica: La clase coordenada geográfica

 

1.     Crea un nuevo proyecto Java con nombre Coordenadas_Geograficas

2.     Crea una clase con el nombre GeoPunto.

3.     Define dos atributos longitud y latitud tipo double.

4.     Define el constructor de la clase.

5.     Define el método toString() de forma similar a como se hizo en la clase Complejo.

6.     Define el método  double distancia(GeoPunto punto) para aproximar la distancia en metros entre dos coordenadas. Podemos utilizar el algoritmo Haversine:  

R = radio medio de la Tierra (6,378km)
Δlat = lat2− lat1
Δlong = long2− long1
a = sin²(Δlat/2) + cos(lat1) cos(lat2) sin²(Δlong/2)
c = 2 atan2(√a, √(1−a))
d = R c

Una posible implementación en Java de este algoritmo se muestra a continuación:

    final double RADIO_TIERRA = 6371000; // en metros
    double dLat = Math.toRadians(latitud - punto.latitud);
    double dLon = Math.toRadians(longitud - punto.longitud);
    double lat1 = Math.toRadians(punto.latitud);
    double lat2 = Math.toRadians(latitud);
    double a =    Math.sin(dLat/2) * Math.sin(dLat/2) +
                  Math.sin(dLon/2) * Math.sin(dLon/2) *
                  Math.cos(lat1) * Math.cos(lat2);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return c * RADIO_TIERRA;

7.     Crea la clase Principal de forma similar a como se hizo en el proyecto Complejos.

8.     Ejecuta el proyecto y verifica que todo funciona correctamente.

 

 

 

Comentarios y documentación javadoc

Describir la forma de introducir comentarios y documentar nuestro código.

Los comentarios en Java se introducen de la misma forma que en C o en C++.

// Comentario de una línea

/* Comentario de

varias líneas */

La documentación del código resulta vital si queremos que este sea reutilizable. Java nos permite realizar esta importante tarea utilizando en mínimo esfuerzo. Para descubrir cómo se utiliza te proponemos el siguiente ejercicio.

Ejercicio paso a paso: Documentación del código utilizando javadoc.

1.     Desde Android Studio, accede a File >Settings.. >Editor > General y activa la opción Show quick doc on mouse move.

2.    En el proyecto Complejos visualizar el código de la clase Principal.

3.     Sitúa el ratón sobre la palabra suma. Aparecerá una ventana como la siguiente:

Te preguntarás cómo es posible que Eclipse ya disponga de la documentación de una clase que acabamos de escribir.

4.     Para responder a esta pregunta visualiza la clase Complejo y comprueba que el comentario introducido antes de método suma es:

/** Suma al complejo de este objeto otro complejo.

* @param v el complejo que sumamos

*/

Todo comentario que introduzcamos de la forma /** … */ será utilizado por Java para documentar el elemento que es definido a continuación. Este elemento puede ser una clase, una variable o un método. A este sistema de documentación automática se le conoce como javadoc.

Lee las siguientes secciones del libro:

Si quieres ampliar sobre estos conceptos puedes leer del libro “Pensando en Java” el último apartado del capítulo 2: “Comentarios y documentación empotrada”

 Practica: Documentación de la clase coordenadas geográficas

Documenta todos los elementos de la clase GeoPunto.

 

 

 

El encapsulamiento y la visibilidad en Java http://www.youtube.com/watch?v=HS9jaDsTyTw

Para un diseño adecuado del software resulta imprescindible un correcto encapsulamiento del código. El mayor problema reside en que el software tiende a cambiar con mucha facilidad, (siempre encontramos mejores formas de resolver un problema) y resulta imprescindible que estos cambios afecten lo menos posible a otras partes de código. Pasemos a definir algunos términos de forma más precisa.

Cuando diseñamos un software hay dos aspectos que resultan fundamentales:

Interface: Cómo este software puede ser utilizado.

Implementación: El código utilizado para resolver los distintos algoritmos.

El concepto de interfaz se define en Java como los elementos de una clase que son visibles desde fuera de esta (con visibilidad public). La implementación se define creando unos determinados atributos y escribiendo el código de los diferentes métodos.

El encapsulamiento consiste en ocultar la implementación y los atributos de un objeto, de manera que sólo se puede cambiar su estado mediante ciertas operaciones definidas en el interface del objeto. Dicho de otra forma, procurar que el interface sea lo más independiente posible de la implementación.

En Java el encapsulamiento está estrechamente relacionado con la visibilidad. Para indicar la visibilidad de un elemento (tanto atributos como métodos) podemos anteceder una de las siguientes palabras reservadas:

public: accesibles desde cualquier clase.

private: sólo son accesibles por la clase actual.

protected: sólo por la clase actual, sus descendientes y clases de nuestro paquete.

<si no indicamos nada> sólo son accesibles por clases de nuestro paquete.
Acceso a los atributos de la clase

Los atributos de una clase están estrechamente relacionados con su implementación. Por esta razón conviene marcarlos como private e impedir su acceso desde fuera. De esta forma en un futuro podremos cambiar la representación interna del objeto sin alterar su interface.

Aunque en la teoría esta afirmación parece lógica, en la práctica resulta difícil de seguir. Pensemos en las dos clases que hemos diseñado. En la de los números complejos al haber puesto private en los atributos no vamos a permitir que acceder la parte entera e imaginaria del objeto:

    class Complejo {
        private double real, imaginario;
        …

Lo mismo ocurre con longitud y latitud de una coordenada geográfica. Por lo tanto, resulta imposible consultar o modificar esta información desde fuera de la clase. Para solucionar este problema vamos a utilizar los métodos getters y setters (obtención y establecimiento). Estos métodos son utilizados para consultar el valor de un atributo (getter) o para modificarlo (setter). Resulta imprescindible indicar que tienen una visibilidad public para que puedan ser invocados desde fuera de la clase. Por ejemplo, para el atributo real escribiríamos los métodos:

    public double getReal() {
       return real;
    }
    public void setReal(double real) {
       this.real = real;
    }

Esta forma de trabajar puede parecer algo engorrosa, pero tiene sus ventajas:

    Como veremos en el siguiente apartado, podemos cambiar la representación interna de la clase sin alterar el interface
    Verificar que los valores son correctos:

    public void setReal(double real) {
       if (real>100000) {lanzamos una excepción}
       else this.real= real;
    }

    Modificar otros aspectos del objeto o lanzar eventos:

    public void setReal(double real) {
       contadorModificaciones++; //Con fines estadísticos
       lanzamos el evento: onComplejoChange
       this.real= real;
    }

Resulta tan frecuente su utilización que Eclipse incorpora una herramienta para crearlos de forma automática. Realiza el siguiente ejercicio para aprender su funcionamiento:

Ejercicio paso a paso: Creación automáticas de getters y setters

1.     En el  proyecto Complejos, abre la clase Complejo.

2.     Pulsa con el botón derecho sobre el código y selecciona la siguiente opción: con Android Studio  Generate.../ Getter and Setter  y con Eclipse Source / Generate Getters and Setters...

3.     Selecciona los dos atributos de la clase y pulsa OK. Verás cómo se inserta el siguiente código:

    public double getReal() {
       return real;
    }
     
    public void setReal()double real){
       this.real = real;
    }
     
    public double getImaginario(){
       return imaginario;
    }
     
    public void setImaginario(double imaginario) {
       this.imaginario = imaginario;
    }

4.     Pulsa en el botón Guardar para almacenar el fichero.

Practica: Getters y setters en la clase coordenadas geográficas

Inserta en la clase GeoPunto los getters y setters necesarios para acceder a sus atributos.
Cambio de la representación interna de una clase

Tras insertar los cuatro métodos del ejercicio anterior, uno podría pensar que el resultado es el mismo que si hubiéramos puesto public delante de los dos atributos. No es exactamente así, imaginemos que más adelante queremos verificar que la latitud de un GeoPunto esté en el rango [-90, 90], y en caso contrario lanzar una excepción. Si los usuarios de la clase acceden directamente al atributo esto no será posible. Más todavía, imagina que en un momento determinado queremos cambiar la representación interna de un número complejo para utilizar módulo y fase en lugar de parte entera y parte imaginaria. Si hemos tenido la precaución de no publicar los atributos, será posible realizar este cambio sin cambiar el interface de la clase.

    class Complejo {
    //declaración de atributos
    private double modulo, fase;
     
    //declaración de constructor
    public Complejo(double real, double imaginario) {
       modulo = Math.hypot(real, imaginario);
       fase = Math.atan2(imaginario, real);
    }
     
    //declaración de métodos
    public double getReal() {
       return modulo * Math.cos(fase);
    }
    …

Cuando decimos que no cambiamos el interface de la clase, queremos decir que no hemos modificado ninguna de las llamadas marcadas como public. Por lo tanto, no tendremos que modificar ninguna línea del código que utiliza la clase Complejo. Aunque la forma interna de trabajar ha cambiado radicalmente. En la nueva implementación algunas operaciones son mucho más rápidas (como obtener el módulo), pero otras son mucho más lentas (como la suma). Si quieres puedes ver el ejemplo completo de cómo se podría implementar esta clase en el siguiente fichero.

Practica: Cambio de representación de la clase coordenadas geográficas

Modifica la clase GeoPunto para que los atributos longitud, latitud sean representados mediante un int en lugar de con double. Para disponer de una precisión adecuada ahora representarán millonésimas de grado en lugar de grados. De esta forma tenemos una representación más compacta. Como veremos más adelante esta representación es la utilizada en el API de Google Maps. IMPORTANTE, el interfaz de la clase ha de permanecer exactamente igual. Para el constructor puedes utilizar el siguiente código.

    public GeoPunto(double longitud, double latitud) {
       this.longitud = (int) (longitud * 1E6);
       this.latitud = (int) (latitud * 1E6);
    }

 

 

La clase Lugar:    Crear la clase fundamental de la aplicación Mis Lugares.

 

La aplicación Mis Lugares permite gestionar una colección de lugares. Para cada lugar vamos a poder almacenar mucha información: nombre, dirección, posición geográfica, etc. El primer paso a realizar va a ser crear una clase que nos permita trabajar en Java con este tipo de información.

Ejercicio paso a paso: Creación de la clase Lugar

Android Studio está pensado exclusivamente para crear aplicaciones Android. Sin embargo, si sigues los siguientes pasos podrás crear una aplicación 100% Java.

1.    Crea un nuevo proyecto (File > New Project..) con los siguientes datos:

Application name: Mis Lugares Java

Package name: org.example.mislugares

☑ Phone and Tablet

    Minimum SDK: API 15 Android 4.0.3 (IceCreamSandwich)

Add an activity: Add No Activity

NOTA: Deja el resto de los parámetros con su valor por defecto.

2.   Pulsa en File > New > New Module. Selecciona Java Library y pulsa Next.

3.    Introduce en Library name Mislugares, como Java pakage name: org.example.mislugares, y en Java class name: Lugar. Pulsa el botón Finish. Se creará un nuevo módulo Java dentro de tu proyecto Android.

4.   Reemplaza el código  de la clase Lugar por el siguiente:

    package org.example.mislugares;
    public class Lugar {
           private String nombre;
           private String direccion;
           private GeoPunto posicion;
           private String foto;
           private int telefono;
           private String url;
           private String comentario;
           private long fecha;
           private float valoracion;
           public Lugar(String nombre, String direccion, double longitud,
                 double latitud, int telefono, String url, String comentario,
                 int valoracion) {
                 fecha = System.currentTimeMillis();
                 posicion = new GeoPunto(longitud, latitud);
                 this.nombre = nombre;
                 this.direccion = direccion;
                 this.telefono = telefono;
                 this.url = url;
                 this.comentario = comentario;
                 this.valoracion = valoracion;
           }
    }

Observa como se definen los atributos de la clase y como en el constructor se inicializa para un objeto concreto según los parámetros indicados. En estos parámetros no se indica el atributo fecha. Este representa el día y la hora en que visitamos ese lugar por última vez. Se codifica mediante un long (número entero de 64 bits), que supondremos en formato Epoch time o tiempo Unix [0]. Es decir, número de milisegundos transcurridos desde 1970.  El método System.currentTimeMillis() nos devuelve la fecha y hora actual en este formato. Por lo tanto, siempre que usemos este constructor, en fecha se almacenará el instante en que él objeto fue creado.

5.    Crea los métodos getters y setters para acceder a todos los atributos de la clase. Solo tienes que pulsar con el botón derecho y seleccionar la opción  Generate… > Getter and Setter y  selecciona  todos los atributos mientras mantienes pulsada la tecla Ctrl.

6.    Pulsa con el botón derecho sobre el código y selecciona la opción Generate... > toString()... Selecciona todos los atributos y pulsa en OK. Se añadirá un método similar a:

    @Override
    public String toString() {
           return "Lugar [nombre="+ nombre+ ", direccion="+ direccion
                 + ", posicion="+ posicion+ ", foto="+ foto+ ", telefono="
                 + telefono+ ", url="+ url+ ", comentario="+ comentario
                 + ", fecha="+ fecha+ ", valoracion="+ valoracion+ "]";
    }

NOTA: El significado de @Override se explica más adelante.

7.    Dentro del  explorador del proyecto mislugares > java > org.example.mislugares, pulsa con el botón derecho y selecciona New > Java Class.

8.    Introduce en el campo Name:   GeoPunto y pulsa Ok. Reemplaza el código por el siguiente (dejando la línea del package):

    public class GeoPunto {
           private double longitud, latitud;
           public GeoPunto(double longitud, double latitud) {
               this.longitud= longitud;
               this.latitud= latitud;
           }
           public String toString() {
               return new String("longitud:" + longitud + ", latitud:"+ latitud);
           }
           public double distancia(GeoPunto punto) {
               final double RADIO_TIERRA = 6371000; // en metros
               double dLat = Math.toRadians(latitud - punto.latitud);
               double dLon = Math.toRadians(longitud - punto.longitud);
               double lat1 = Math.toRadians(punto.latitud);
               double lat2 = Math.toRadians(latitud);
               double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
                          Math.sin(dLon/2) * Math.sin(dLon/2) *
                          Math.cos(lat1) * Math.cos(lat2);
               double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
               return c * RADIO_TIERRA;
           }
    }

9.    Crea  en esta clase los métodos getters y setters para acceder a los dos atributos. Igual que antes, pulsa con el botón derecho y seleccionar la opción Generate… > Getter and Setter.  

10.    Crea una nueva clase en el paquete  org.example.mislugares, pulsando con el botón derecho y selecciona New > Java Class.

11.   Introduce en el campo Name: Principal y pulsa Ok.

12.   Reemplaza el código por el mostrado (dejando la línea del package):

    class Principal {
           public static void main(String[] main) {
             Lugar lugar = new Lugar("Escuela Politécnica Superior de Gandía",
                  "C/ Paranimf, 1 46730 Gandia (SPAIN)", -0.166093, 38.995656,
                  962849300, "http://www.epsg.upv.es",
                  "Uno de los mejores lugares para formarse.", 3);
             System.out.println("Lugar " + lugar.toString());
           }
    }

La clase Principal es algo atípica: no tiene atributos ni constructor, únicamente el método main. Cuando en un proyecto existe una clase que tiene un método con este perfil, es el que se llama para comenzar la ejecución. Como parámetros, este método recibe un array de Strings. Esta información tiene interés cuando el programa se ejecuta desde la línea de comandos con parámetros.

13.   Pulsa en el botón desplegable a la derecha del botón Run . Selecciona Edit Configurations...

14.    En la nueva ventana, haz clic en  el  signo + de la esquina superior izquierda y selecciona Application. Aparecerá una nueva configuración de aplicación. Selecciona en Name: mislugares, en Main class: org.example.mislugares.Principal y en Use classpath of module: mislugares. Pulsa en OK.

15.   Pulsa el botón Ejecución y verifica que el resultado que aparece en la ventana de Run es similar a:

“C\Program ...

Lugar {nombre=Escuela Politécnica Superior de Gandía,
direccion=C/ Paranimf, 1 46730 Gandia (SPAIN),
posicion=longitud:-0.166093, latitud:38.995656, foto=null,
telefono=962849300, url=http://www.epsg.upv.es,
comentario=Uno de los mejores lugares para formarse.,
fecha=1392332854758, valoracion=3.0}

Process finished with exit code 0

[0] http://es.wikipedia.org/wiki/Tiempo_Unix

 

 

 

 

La herencia en Java  
La sobrecarga en Java
El polimorfismo en Java  
Clases abstractas, interfaces y herencia múltiple
Tipos enumerados en Java  
Las colecciones en Java  
Referencia Java
Examen del tema 1  
examen unidad