TEMA 9 - INTERFACES

- Clases abstractas y métodos abstractos

- Interfaces
-  Desacoplamiento completo
- "Herencia múltiple" en Java
-  Ampliación de la interfaz mediante herencia
    - Colisiones de  nombres al combinar interfaces
- Adaptación a una interfaz
-  Campos en las interfaces
    - Inicialización de campos en las  interfaces
- Anidamiento de interfaces
- Interfaces y  factorías

Las interfaces y las clases abstractas proporcionan una forma más estructurada de separar la interfaz de la implementación.

Estas características no son tan comunes en los lenguajes de programación. Existen palabras clave en Java para estos conceptos, por tanto, estas ideas fueron consideradas importantes para proporcionar soporte directo.
Una clase abstracta está entre una clase normal y una interfaz. Se trata de una herramienta importante y necesaria para construir clases que dispongan de algunos métodos no implementados.

ÍNDICE DE TEMAS

TEMAS DEL TUTORIAL
Tema 1
- Introducción a los objetos
Tema 2
- Todo es un objeto
Tema 3
- Operadores
Tema 4
- Control de ejecución
Tema 5
- Inicialización y limpieza
Tema 6
- Control de acceso
Tema 7
- Reutilización de clases
Tema 8
- Polimorfismo
Tema 9
- Interfaces

Otros enlaces interesantes dentro del blog:
- Ejercicios
- Compilación, ejecución y classpath
- Diferencias entre método equals() y operador ==
- Classpath y package en Linux y Windows
- Classpath y package en Netbeans
- Importación estática de miembros

Ejercicios Tema 8

Después de bastante tiempo sin actualizar el blog por diferentes motivos, acabo de colgar los 17 ejercicios del tema 8. Esta vez los he hecho con Eclipse. Como siempre digo, la solución a los ejercicios es personal, por tanto, para un mismo ejercicio puede haber otras soluciones diferentes. Si véis algún error o no estáis de acuerdo con alguna solución, por favor, no dudéis en decírmelo. Podéis ver los ejercicios en:

Ejercicios Tema 8

POLIMORFISMO

TEMA 8

- Nuevas consideraciones sobre la generalización
   - Por qué olvidar el tipo de un objeto
- El secreto
   - Acoplamiento de las llamadas a métodos
   - Especificación del comportamiento correcto
   - Ampliabilidad
   - Error: "sustitución" de métodos private
   - Error: campos y métodos static
- Constructores y polimorfismo
   - Orden de las llamadas a los constructores
   - Herencia y limpieza
   - Comportamiento de los métodos polimórficos dentro de 
     los constructores   
- Tipos de retorno covariantes
- Diseño de sistemas con herencia
   - Sustitución y extensión
   - Especialización e información de tipos en tiempo de
     ejecución

"En ocasiones me he preguntado, Sr. Babbage, si introduce en la máquina datos erróneos, ¿podrá suministrar las respuestas correctas? Debo confesar que no soy capaz de comprender qué tipo de confusión de ideas puede hacer que alguien plantee semejante pregunta". Charles Babbage (1791-1871)

El polimorfismo, la abstracción de datos y la herencia son las tres características esenciales de un lenguaje de programación orientado a objetos.

EJERCICIOS TEMA 7

Por fin tenéis listos los ejercicios del tema 7, son 24, bueno alguno más porque he hecho dos versiones de alguno de ellos. Esta vez no he utilizado Netbeans sino que los he hecho con gedit, el editor de textos de Linux y los he compilado y ejecutado desde la consola. Espero que os sean de utilidad y si tenéis alguna duda o sugerencia, por favor no dudéis en hacerlo. Para ver los ejercicios pinchad en el siguiente enlace:

Ejercicios Tema 7

REUTILIZACIÓN DE CLASES

TEMA 7

- Sintaxis de la composición
- Sintaxis de la herencia
   - Inicialización de la clase base
- Delegación
- Combinación de la composición y de la herencia
   - Cómo garantizar una limpieza apropiada
   - Ocultación de nombres
- Cómo elegir entre la composición y la herencia
- protected
- Upcasting (generalización)
   - ¿Por qué "upcasting"?
   - Nueva comparación entre la composición y la herencia
- La palabra clave final
   - Datos final
   - Métodos final
   - Clases final
   - Una advertencia sobre final
- Inicialización y carga de clases
   - Inicialización con herencia

Una de las características más atractivas de Java es la posibilidad de reutilizar el código. Pero para ser verdaderamente revolucionario es necesario ser capaz de hacer mucho más que simplemente copiar el código y modificarlo.

EJERCICIOS TEMA 6

Aquí tenéis los ejercicios del Tema 6, Control de acceso. Ha sido bastante complicada la realización de los ejercicios, tanto por falta de tiempo, como por algunos problemas con Netbeans y la dificultad de alguno de ellos. Eso sí, vais a aprender mucho haciendo estos ejercicios, tratad de hacerlos sin mirar la solución porque aprenderéis cosas muy útiles.
Podéis descargarlos desde:

Ejercicios Tema 6

Si utilizáis el bloc de notas para realizar los ejercicios, tratáis de compilar los ejercicios descargados y os da un error raro de compilación, guardad el archivo cambiando la codificación de caracteres, es una opción que os sale en Archivo - Guardar como.
Por favor, si tenéis alguna sugerencia o no estáis de acuerdo con la resolución de alguno de los ejercicios no dudéis en comentarlo.
Un saludo.

IMPORTACIÓN ESTÁTICA DE MIEMBROS

El ejercicio 3 dice:

Cree dos paquetes: debug y debugoff, que contengan una clase idéntica con un metodo debug(). La primera versión debe mostrar su argumento String en la consola, mientras que la segunda no debe hacer nada. Utilice una linea static import para importar la clase en un programa de prueba y demuestre el efecto de la compilacion condicional.

Como vemos, el ejercicio pide que se utilicen importaciones estáticas, vamos a explicar un poco qué es esto. En Java, tenemos una clase Math, con varias constantes y métodos estáticos. Por ejemplo, tenemos la constante PI:

   public static final double PI = 3.14159265358979323846;

La palabra final significa que este valor es constante y no varía. Al ser esta constante estática, para referirnos a ella desde cualquier otra clase sin necesidad de importar la clase Math, tendríamos que escribir:

   System.out.println("Numero PI: "+Math.PI);

Como vemos hay que utilizar el nombre de la clase para referirnos a la constante. Hay una forma de evitar esto, podemos importar la variable:

   import static java.lang.Math.PI;

CLASSPATH Y PACKAGE EN NETBEANS

Vamos a ver cómo he hecho el ejercicio 1 del Tema 6 con Netbeans. El enunciado del ejercicio dice:

Crea una clase dentro de un paquete. Crea una instancia de esa clase fuera de dicho paquete.
En primer lugar vamos a crear un proyecto nuevo, como estamos en el Tema 6 lo voy a llamar Tema_6:

CLASSPATH Y PACKAGE EN LINUX Y WINDOWS

Para explicaros de una forma sencilla la variable CLASSPATH y la creación de paquetes, vamos a hacer el ejercicio 1 de este tema con el jdk a través de la consola o terminal. El ejercicio 1 dice:

Cree una clase dentro de un paquete. Cree una instancia de esta clase fuera de dicho paquete.

Voy a crear dos clases, la clase Ejer_1 es la que se va a ejecutar y, por tanto, va a contener el método main. Esta clase la voy a crear en la carpeta:

/home/arween/Documentos/Java/PiensaEnJava/EjerciciosPiensaEnJava4/Tema_6
El código de esta clase es:

// Clase Ejer_1.java
import tema6.*;

public class Ejer_1{

   public static void main(String args[]){       
      Lib1 lib1=new Lib1();
   }
   
}

CONTROL DE ACCESO

TEMA 6

- package: la unidad de biblioteca
- Organización del código
- Creación de nombres de paquetes unívocos
- Una biblioteca personalizada de herramientas
- Utilización de importaciones para modificar el comportamiento
- Un consejo sobre los nombres de paquete
- Especificadores de acceso Java
- Acceso de paquete
- public: acceso de interfaz
- private: ¡no lo toque!
- protected: acceso de herencia
- Interfaz e implementación
- Acceso de clase

El control de acceso (u ocultación de la implementación) trata acerca de "que no salgan las cosas a la primera".

El trabajo de rediseño consiste en reescribir código que ya funciona para hacerlo más legible, comprensible y mantenible.
En diseño orientado a objetos, hay que separar las cosas que cambian de las cosas que permanecen.

EJERCICIOS TEMA 5

Hola a todos:
En primer lugar dar las gracias a la gente que sigue el blog, eso me da muchas fuerzas para seguir adelante.
Están ya disponibles los ejercicios del tema 5, Inicialización y limpieza. Es un tema bastante largo e interesante. Si tenéis cualquier duda o sugerencia por favor no dudéis en hacerla. Los ejercicios los he compilado con Netbeans y con el JDK desde Linux. Si los compiláis desde la consola o terminal quizá os salgan advertencias porque no he quitado acentos ni eñes, si os molesta sólo tenéis que quitarlos de los comentarios.
Los ejercicios los podéis descargar desde:

Ejercicios Tema 5.

Un saludo y gracias.

INICIALIZACIÓN Y LIMPIEZA

TEMA 5

- Inicialización garantizada con el constructor
- Sobrecarga de métodos
   - Cómo se distingue entre métodos sobrecargados
   - Sobrecarga con primitivas
   - Sobrecarga de los valores de retorno
- Constructores predeterminados
- La palabra clave this
   - Invocación de constructores desde otros conductores
   - El significado de static
- Limpieza: finalización y depuración de memoria
   - ¿Para qué se utiliza finalize()?
   - Es necesario efectuar las tareas de limpieza
   - La condición de terminación
   - Cómo funciona un depurador de memoria
- Inicialización de miembros
   - Especificación de la inicialización
- Inicialización mediante constructores
   - Orden de inicialización
   - Inicialización de datos estáticos
   - Inicialización static explícita
   - Inicialización de instancias no estáticas
- Inicialización de matrices
   - Listas variables de argumentos
- Tipos enumerados

A medida que se abre paso la revolución informática, la programación "no segura" se ha convertido en uno de los mayores culpables del alto coste que tiene el desarrollo de programas.

Dos cuestiones relacionadas con la seguridad son la inicialización y la limpieza. En Java los objetos tienen que ser inicializados antes de ser utilizados, para ello se utiliza un constructor, que es un método especial que se invoca automáticamente cada vez que se crea un objeto. Además Java dispone de un depurador de memoria que libera los recursos de memoria cuando ya no se utilicen. En este tema se van a ver ambas cuestiones.

EJERCICIOS TEMA 4

Acabo de subir las soluciones de los ejercicios del tema 4 del libro Piensa en Java Edición 4. Por favor, si tenéis alguna sugerencia o pensáis que algún ejercicio tiene algún error, no dudéis en comentármelo. Como siempre las soluciones a los ejercicios pueden ser varias, las soluciones que yo doy son personales. Para descargar los ejercicios:

Ejercicios Tema 4

Un saludo y gracias.

CONTROL DE EJECUCIÓN

CONTROL DE EJECUCIÓN

TEMA 4

- true y false
- if - else
- Iteración
   - do - while
   - for
   - El operador coma
- Sintaxis foreach
- return
- break y continue
- La despreciada instrucción "goto"
- switch

Al igual que las criaturas sensibles, un programa debe manipular su mundo y tomar decisiones durante la ejecución. En Java, las decisiones se toman mediante las instrucciones de control de ejecución.

En este tema vamos a ver las instrucciones de control de ejecución.

TRUE Y FALSE
Todas las instrucciones condicionales utilizan la veracidad o la falsedad de una expresión condicional para seleccionar una ruta de ejecución. Es decir, se compararán una serie de valores mediante los operadores relacionales y dependiendo del resultado (true o false) la ejecución irá por un camino u otro.

EJERCICIOS TEMA 3

Hola a todos.
Ya podéis descargaros las soluciones de los ejercicios del Tema 3 del libro Piensa en Java Edición 4. Recordad que los ejercicios los resuelvo desde mi punto de vista, por tanto, puede haber multitud de soluciones para cada uno. Si tenéis alguna sugerencia o detectáis cualquier error, por favor no dudéis en comentarlo. Los ejercicios están compilados de manera correcta en Ubuntu, y los podéis descargar desde:

Ejercicios Tema 3

Un saludo y espero que os guste.

Diferencias entre método equals() y operador ==

Si comparamos tipos primitivos con los operadores == o != el resultado es el esperado. Sin embargo, si comparamos objetos con estos dos operadores el resultado puede no ser el esperado. Tenemos el ejemplo siguiente:

 public class Equivalencia {
   public static void main(String[] args) {
     Integer n1 = new Integer(47);
     Integer n2 = new Integer(47);
 
     System.out.println("n1==n2: "+n1 == n2);
     System.out.println("n1!=n2: "+n1 != n2);

     String s1 = new String("Hola");
     String s2 = new String("Hola");

     System.out.println("s1==s2: "+s1 == s2);
     System.out.println("s1!=s2: "+s1 != s2);
   }
} 

Si lo ejecutamos el resultado es:

n1==n2: false
n1!=n2: true
s1==s2: false
s1!=s2: true

OPERADORES

TEMA 3

- Instrucciones simples de impresión
- Utilización de los operadores Java
- Precedencia
- Asignación
 - Creación de alias en las llamadas a métodos
- Operadores matemáticos
 - Operadores unarios mas y menos
- Autoincremento y autodecremento
- Operadores relacionales
 - Comprobación de la equivalencia de objetos
- Operadores lógicos
 - Cortocircuitos
- Literales
 - Notación exponencial
- Operadores bit a bit
- Operadores de desplazamiento
- Operador ternario if - else
- Operadores + y += para String
- Errores comunes a la hora de utilizar operadores
- Operadores de proyección
 - Truncamiento y redondeo
 - Promoción
- Java no tiene operador "sizeof"
- Compendio de operadores

En el nivel inferior, los datos en Java se manipulan utilizando operadores.

INSTRUCCIONES SIMPLES DE IMPRESIÓN
Si nos fijamos en la siguiente instrucción

 System.out.println("Un montón de texto que escribir");

EJERCICIOS TEMA 2

Hola:
Aquí tenéis los Ejercicios del Tema 2. La solución a estos ejercicios es algo personal, por lo que las soluciones pueden ser múltiples. He quitado acentos, eñes y diéresis de los comentarios porque al compilarlo en Linux me salían un montón de Warnings (advertencias). Espero que os sea útil.

Los ejercicios los podeis descargar desde:

Ejercicios Tema 2.

Un saludo.