Tutorial Java by expreso: 13. Imágenes en Ventana

 

En este tutorial vamos a ver como usando java y bluej podemos insertar nuestras imágenes en las aplicaciones que creemos. Es una aplicación sencilla que consiste en la creación de una ventana en la que pondremos las imágenes que nosotros mismos hemos creado o que tenemos en nuestro ordenador. Esta forma de insertar imágenes nos abre un gran abanico de posibilidades a la hora de programar pues puede dar a nuestros programas un toque mas profesional y estariamos ante los primeros pasos de crear nuestras primeras aplicaciones "2d" dotadas de animación, ya sean aplicaciones de trabajo, juego, etc.

Tutorial Java by expreso: 12. Pintar en Ventana

 

En este tutorial número 12 de Tutorial Java by expreso vamos a ver una primera aproximación de como podemos insertar imágenes en nuestros programas, es una toma de contacto con la clase canvas que será la que utilizaremos en el vídeo para insertar varios puntos de diferentes colores, serán los cimientos de nuestras interfaces gráficas de usuarios. En vídeos siguientes iremos añadiendo nuestras propias imágenes, las dotaremos de movimiento y sentaremos las bases de nuestros futuros proyectos en 2d.

Tutorial Java by expreso: 11. Crear número aleatorio

Tutorial Java by expreso: 11. Crear número aleatorio

En este vídeo vemos lo fácil que es crear un número aleatorio usando para ello la clase random. En programación la creación de números aleatorios es fundamental pues con ellos se pueden hacer infinidad de cosas en infinidad de campos como por ejemplo en juegos (para crear disparos, mounstros, etc) en programas que queremos que se comporten de una manera no predeterminada como por ejemplo en ese programa con múltiples ventanas de un tutorial anterior, etc. En definitiva los números aleatorios son muy importantes y nos serán muy útiles en programación.
Cómo nota aclaratoria decir que "lo aleatorio" en programación no existe porque la clase que usamos para crear un número sigue unas reglas previamente establecidas y programadas y que al ser tan complejas nos da la impresión de ser realmente aleatorio, pero lo correcto sería hablar de pseudoaleatorio.

Tutorial Java by expreso: 10. Programa con múltiples ventanas

Tutorial Java by expreso: 10. Programa con múltiples ventanas

 

En este tutorial vamos a ver como un programa o un solo procedimiento puede crear todas las ventanas que queramos, en este caso lo hacemos de forma "manual" creando un número pequeño de ventanas, pero cómo vemos en el propio vídeo eso se puede hacer con un for o con while por ejemplo para que se creen una número grande de ventanas (cientos o miles) haciendo de nuestro programa un pequeño programa malicioso consistente en crear muchísimas ventanas sin ninguna consecuencia para el usuario (lo único la molestia de tener que cerrarlas)

 

 

 

 

Tutorial Java by expreso: 9. Crear una ventana con barra de herramientas

Tutorial Java by expreso: 9. Crear una ventana con barra de herramientas

 

En esta ocasión vamos a crear una ventana que en su interior tendrá una etiqueta con texto y que además tendrá una barra de herramientas a la que asignaremos alguna función:

 

 

Tutorial Java by expreso: 8. Crear una ventana con un botón

Tutorial Java by expreso: 8. Crear una ventana con un botón

 

En esta ocasión vamos a ver como se crea una ventana con JFrame que a su vez tenga un botón con JButton que muestre un mensaje en pantalla al pulsarlo.

Tutorial Java by expreso: 7. Crear una Barra de Progreso

Tutorial Java by expreso: 7. Crear una Barra de Progreso

 

En este vídeo podemos ver como crear una barra de progreso en bluej usando para ello la clase JProgressBar, así como ejemplos de su funcionamiento y modificación

Tutorial Java by expreso: 6. Crear una Ventana

Tutorial Java by expreso: 6. Crear una Ventana. Vídeo básico sobre como crear una ventana en Java con JFrame

 

Tutorial Java by expreso: 5. Estructura de una Clase

Episodio 5 de Tutorial Java by expreso: Estructura de una clase

 

Aquí podremos ver la estructura completa de una clase con sus campos, constructores y métodos, así como algún ejemplo de funcionamiento.

 

 

Tutorial Java by expreso: 4. Comentarios de Documentación

Tutorial Java by expreso: 3. Comentarios

Ya está disponible el vídeo 3 de Tutorial Java by expreso: 3. Comentarios:

Tutorial Java by expreso: 2. Programa básico

Tutorial sobre como crear un programa completo en java usando bluej:

Tutorial Java by expreso: 1. Instalación de BlueJ

Aquí os dejo el primer vídeo de la serie de Tutoriales Java by expreso:

1. Instalación de Bluej

Porque La BIOS es El BIOS y no es La BIOS

Es muy común en la mayoría de personas de habla castellana decir habitualmente La BIOS, pero eso es una incorrección, pues BIOS es Basic Input Output System que traducido al castellano es Sistema Básico de Entrada y Salida. Por tanto al ser UN sistema debe decirse El BIOS y no La BIOS, pues la sistema básico de entrada y salida es incorrecto. 

3 Bolas



3 bolas que se mueven por la pantalla

3 Bolas que se mueven por la pantalla es una aplicación que consiste en una ventana que tiene 3 bolas dentro y que se van moviendo por la misma automáticamente:

3 Bolas

Si queréis el código fuente o cualquier otra cosa decirlo por los comentarios y os lo pongo

Bola que se mueve

Bola 3d en Java

Hola, aquí os dejo un pequeño programa que consiste en una bola en "3D" que se mueve por la pantalla mediante los cursores:

Bola

Si queréis saber más sobre esta pequeña animación así cómo el código fuente o lo que se os ocurra no dudéis en ponerlo en los comentarios que enseguida os pongo lo que sea

Ejemplo de animación 2D en Java

Animación 2d en Java con Bluej

Hola, aquí os dejo un pequeño ejemplo de animación 2D en java, consiste en una serie de imágenes que se muestran en pantalla y que se desplazan horizontalmente. (el siguiente paso para crear un space invaders por ejemplo, sería controlar la imagen de abajo mediante teclado y añadir los disparos y detalles del juego)

Animación2D




(En esta entrada tenéis un Space Invaders que hice yo para una asignatura: http://www.juegosoftware.com/2014/12/space-invaders-en-java-con-bluej.html)

Código Fuente Space Invaders Java Bluej Poo

Hola, aquí os dejo el código fuente de un Space Invaders en Java realizado con Bluej. Son 3 clases y para que funcione deberéis añadir en la carpeta del proyecto imagenes del alien, laser, misil y nave con ese mismo nombre. Espero que os ayude.

Código Fuente Space Invaders Java Bluej

(En esta entrada tenéis un Space Invaders que hice yo mismo para una asignatura:

http://www.juegosoftware.com/2014/12/space-invaders-en-java-con-bluej.html 

es diferente al del código fuente, pero el concepto es el mismo)

Si queréis algún detalle o más información ponerlo por los comentarios

Space Invaders Java POO

Hola, aquí os dejo un Space Invaders hecho en Java con BlueJ:

SpaceInvaders












(En este post tenéis un Space Invaders que hice yo mismo para una asignatura: http://www.juegosoftware.com/2014/12/space-invaders-en-java-con-bluej.html)

Space Invaders

Space Invaders

En 1978 un japonés que respondía al nombre de Toshihiro Nishikado planteó un singular videojuego de acción en el cual nuestro objetivo era impedir una maligna invasión extraterrestre sobre nuestro planeta. Su lanzamiento fue primero en Japón y poco después, como si de una invasión se tratase, Space Invader se extendió por todos los salones recreativos del mundo. Space Invaders sentó los estándares en el género de los “matamarcianos”. A día de hoy es incalculable el número de copias que existen de este juego.

Como curiosidades destaca que en Japón empezó a haber gran escasez de monedas, dado que eran utilizadas en las salas de videojuegos. El gobierno tuvo que aumentar el número de monedas para hacer frente a esa escasez.

(En esta entrada tenéis un Space Invaders que hice yo para una asignatura: http://www.juegosoftware.com/2014/12/space-invaders-en-java-con-bluej.html)

Características de JAVA

Java es uno de los lenguajes de programación más usado en todo el mundo y con más posibilidades. Todo ello es debido a que Java supone un significativo avance en el mundo de los entornos software, teniendo tres elementos claves que diferencian a este lenguaje:

• Es un lenguaje de programación que ofrece la potencia del diseño orientado a objetos con una sintaxis fácilmente accesible y un entorno robusto y agradable.
• Proporciona un conjunto de clases potente y flexible.
• Pone al alcance de cualquiera la utilización de aplicaciones que se pueden incluir directamente en páginas Web (aplicaciones denominadas applets).

Características:

-Orientación a objetos

En este aspecto Java fue diseñado partiendo de cero, no siendo derivado de otro lenguaje anterior y no tiene compatibilidad con ninguno de ellos.

En Java el concepto de objeto resulta sencillo y fácil de ampliar. Además se conservan elementos "no objetos", como números, caracteres y otros tipos de datos simples.

-Riqueza semántica

Pese a su simpleza se ha conseguido un considerable potencial, y aunque cada tarea se puede realizar de un número reducido de formas, se ha conseguido un gran potencial de expresión e innovación desde el punto de vista del programador.

- Robusto

Java verifica su código al mismo tiempo que lo escribe, y una vez más antes de ejecutarse, de manera que se consigue un alto margen de codificación sin errores. Se realiza un descubrimiento de la mayor parte de los errores durante el tiempo de compilación, ya que Java es estricto en cuanto a tipos y declaraciones, y así lo que es rigidez y falta de flexibilidad se convierte en eficacia. Respecto a la gestión de memoria, Java libera al programador del compromiso de tener que controlar especialmente la asignación que de ésta hace a sus necesidades específicas. Este lenguaje posee una gestión avanzada de memoria llamada gestión de basura, y un manejo de excepciones orientado a objetos integrados. Estos elementos realizarán muchas tareas antes tediosas a la vez que obligadas para el programador.

- Modelo de objeto rico

Existen varias clases que contienen las abstracciones básicas para facilitar a los programas una gran capacidad de representación. Para ello se contará con un conjunto de clases comunes que pueden crecer para admitir todas las necesidades del programador.

Además la biblioteca de clases de Java proporciona un conjunto único de protocolos de Internet.

El conjunto de clases más complicado de Java son sus paquetes gráficos AWT (Abstract Window Toolkit) y Swing. Estos paquetes implementan componentes de una interfaz de usuario gráfica básica común a todos los ordenadores personales modernos.

- Fácil aprendizaje

El único requerimiento para aprender Java es tener una comprensión de los conceptos básicos de la programación orientada a objetos. Así se ha creado un lenguaje simple (aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del programador sin que las interioridades del sistema subyacente sean desveladas.

Java es más complejo que un lenguaje simple, pero más sencillo que cualquier otro entorno de programación. El único obstáculo que se puede presentar es conseguir comprender la programación orientada a objetos, aspecto que, al ser independiente del lenguaje, se presenta como insalvable.

- Completado con utilidades

El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos complejas y sus métodos asociados, que serán de inestimable ayuda para implementar applets y otras aplicaciones más complejas. Se dispone también de estructuras de datos habituales, como pilas y tablas hash, como clases ya implementadas.

Existirá una interfaz Observer/Observable que permitirá la implementación simple de objetos dinámicos cuyo estado se visualiza en pantalla.

El JDK (Java Development Kit) suministrado por Sun Microsystems incluye un compilador, un intérprete de aplicaciones, un depurador en línea de comandos, y un visualizador de applets entre otros elementos.

- Interactivo y animado

Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en red interactivos, por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo que debería suceder y cuándo. Para se da soporte a la utilización de múltiples hilos de programación (multithread).

Las aplicaciones de Java permiten situar figuras animadas en las páginas Web, y éstas pueden concebirse con logotipos animados o con texto que se desplace por la pantalla. También pueden tratarse gráficos generados por algún proceso. Estas animaciones pueden ser interactivas, permitiendo al usuario un control sobre su apariencia.

- Arquitectura neutral

Java está diseñado para que un programa escrito en este lenguaje sea ejecutado correctamente independientemente de la plataforma en la que se esté actuando (Macintosh, PC, UNIX…). Para conseguir esto utiliza una compilación en una representación intermedia que recibe el nombre de códigos de byte, que pueden interpretarse en cualquier sistema operativo con un intérprete de Java. La desventaja de un sistema de este tipo es el rendimiento; sin embargo, el hecho de que Java fuese diseñado para funcionar razonablemente bien en microprocesadores de escasa potencia, unido a la sencillez de traducción a código máquina hacen que Java supere esa desventaja sin problemas.

- Trabajo en red

Java anima las páginas Web y hace posible la incorporación de aplicaciones interactivas y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de manera que los suministradores de información de la Web pueden crear una página de hipertexto (página Web) con una interacción continuada y compleja en tiempo real; el contenido ejecutable es transferido literalmente al ordenador del usuario.

Los protocolos básicos para trabajar en Internet están encapsulados en unas cuantas clases simples. Se incluyen implementaciones ampliables de los protocolos FTP, HTTP, NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado. Esto le permite interactuar con esos servicios de red poderosos sin tener que comprender realmente los detalles de bajo nivel de esos protocolos. Este lenguaje está diseñado para cumplir los requisitos de entrega de contenidos interactivos mediante el uso de applets insertados en sus páginas HTML. Además, las clases de Java admiten muy bien estos protocolos y formatos. El envío de las clases de Java a través de Internet se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo así los típicos problemas de diferencia de versiones.

Java proporciona un conjunto de clases para tratar con una abstracción de los conectores de red (sockets) originales de la versión UNIX de Berckley, encapsular la noción de una dirección de Internet o conectar sockets con flujos de datos de Entrada/Salida.

Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web, puesto que es capaz de captar el interés del usuario durante largo tiempo y permite a los programadores convertir la Web en un sistema de entrega de software.

- Applets

Una applet (miniaplicación) es un pequeño programa en Java transferido dinámicamente a través de Internet. Presentan un comportamiento inteligente, pudiendo reaccionar a la entrada de un usuario y cambiar de forma dinámica. Sin embargo, la verdadera novedad es el gran potencial que Java proporciona en este aspecto, haciendo posible que los programadores ejerzan un control sobre los programas ejecutables de Java que no es posible encontrar en otros lenguajes.

- Seguridad

Existe una preocupación lógica en Internet por el tema de la seguridad: virus, caballos de Troya, y programas similares navegan de forma usual por la red, constituyendo una amenaza palpable. Java ha sido diseñado poniendo un énfasis especial en el tema de la seguridad, y se ha conseguido lograr cierta inmunidad en el aspecto de que un programa realizado en Java no puede realizar llamadas a funciones globales ni acceder a recursos arbitrarios del sistema, por lo que el control sobre los programas ejecutables no es equiparable a otros lenguajes.

Los niveles de seguridad que presenta son:

• Fuertes restricciones al acceso a memoria, como son la eliminación de punteros aritméticos y de operadores ilegales de transmisión.
• Rutina de verificación de los códigos de byte que asegura que no se viole ninguna construcción del lenguaje.
• Verificación del nombre de clase y de restricciones de acceso durante la carga.
• Sistema de seguridad de la interfaz que refuerza las medidas de seguridad en muchos niveles.

- Lenguaje basado en C++

Java fue desarrollado basándose en C++, pero eliminando rasgos del mismo poco empleados, optándose por una codificación comprensible. Básicamente, encontramos las siguientes diferencias con C++:

• Java no soporta los tipos struct, union ni punteros.
• No soporta typedef ni #define.
• Se distingue por su forma de manejar ciertos operadores y no permite una sobrecarga de operadores.
• No soporta herencia múltiple.
• Java maneja argumentos en la línea de comandos de forma diversa a como lo hacen C o C++.
• Tiene una clase String que es parte del paquete java.lang y se diferencia de la matriz de caracteres terminada con un nulo que usan C y C++.
• Java cuenta con un sistema automático para asignar y liberar memoria, con lo que no es necesario utilizar las funciones previstas con este fin en C y C++.

-Gestión de la Entrada/Salida

En lugar de utilizar primitivas como las de C para trabajar con ficheros, se utlizan primitivas similares a las de C++, mucho más elegantes, que permiten tratar los ficheros, sockets, teclado y monitor como flujos de datos.

De este modo se pueden utilizar dichas primitivas para cualquier operación de Entrada/Salida.

- Diferentes tipos de aplicaciones

• Aplicaciones: Se ejecutan sin necesidad de un navegador.
• Applets: Se pueden descargar de Internet y se observan en un navegador.
• JavaBeans: Componentes software Java, que se puedan incorporar gráficamente a otros componentes.
• JavaScript: Conjunto del lenguaje Java que puede codificarse directamente sobre cualquier documento HTML
• Servlets: Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas Web.

Otro ejemplo de TAD

En este post tenemos un ejemplo de TAD con su código fuente completo debidamente comentado para que podáis copiarlo y usarlo sin problemas y así comprender mejor su funcionamiento. Cualquier duda o cosa que queráis no dudéis en ponerla en los comentarios.

/*************************************************/
/* Interfaz del módulo */
/*************************************************/
#pragma once
/********************************
Definicion del tipo abstracto
********************************/
/*
TAD: Tipo abstracto de datos-->
Agrupacion de
  una coleccion de valores
  +
  operaciones de manipulacion */
/******************************/

typedef struct TPunto {
void Leer();
void Escribir();
float Distancia(TPunto p );
/*OCULTACION DE INFORMACION */
 private:
  float x;
  float y;
};

================================================================

================================================================

================================================================

#include <stdio.h>
#include <math.h>
#include "mod.h"
/******************************/
/* Implementacion del tipo abstracto */
/******************************/

void TPunto::Leer()
{
printf("Dame las coordenadas del punto (x,y)");
scanf(" (%g , %g)", &x, &y);
}

void TPunto::Escribir(){
printf(" (%g , %g)", x, y);
}

float  TPunto::Distancia (TPunto p){
float dis_x, dis_y;

dis_x= x-p.x;
dis_y= y-p.y;

return sqrt (dis_x*dis_x + dis_y*dis_y);
}

================================================================

================================================================

================================================================

#include <stdio.h>
#include "mod.h"

int main(){
 TPunto a, b;
 a.Leer();
 b.Leer();
 printf(" Veamos lo leido \n");
 a.Escribir();
 b.Escribir();

 printf("\n distancia = %g \n", a.Distancia(b));

Módulos en programación

En programación un módulo es un fragmento de programa utilizado en algún momento para la construcción del programa completo y podemos definirlo como fragmento de programa desarrollado de forma independiente.

El concepto de módulo, está íntimamente ligado a la idea de abstracción. Un módulo debe definir un elemento abstracto y debe ser usado desde fuera con sólo saber qué hace el módulo, pero sin necesidad de conocer cómo lo hace.

Especificación y realización:

          La especificación del módulo es todo lo que se necesita para poder usar los elementos definidos en él. Esta especificación constituye la interfaz. La ocultación consiste en que el programa que usa un elemento de un módulo sólo tiene visible la información de la interfaz, pero no la realización.

Compilación separada:

          El programa está formado por varios ficheros fuente, cada uno de los cuales se compila por separado.

Compilación segura:

          Al compilar un fichero fuente el compilador comprueba que el uso de elementos de otros módulos es consistente con la interfaz.

Ocultación:

          Al compilar un fichero fuente el compilador no usa información de los detalles de realización de los elementos de otros módulos.

Descomposición modular:

          La posibilidad de compilar módulos de forma separada permite repartir el trabajo de desarrollo de un programa, a base de realizar su descomposición modular.

El acoplamiento entre módulos indica cuántos elementos distintos o características de uno o varios módulos han de ser tenidos en cuenta a la vez al usar un módulo desde otro. Este acoplamiento debe reducirse a un mínimo.

          La cohesión indica el grado de relación que existe entre los distintos elemento de un mismo módulo, y debe ser lo mayor posible. Esto quiere decir que dos elementos íntimamente relacionados deberían ser definidos en el mismo módulo, y que un mismo módulo no debe incluir elementos sin relación entre sí.

Módulos en C+-:

          Un programa descompuesto en módulos se escribe como un conjunto de ficheros fuente relacionados entre sí, y que pueden compilarse por separado. Cada fichero fuente constituye así una unidad de compilación.

Proceso de compilación simple:

          Un fichero fuente es un fichero de texto que contiene el código de uan unidad de compilación, es decir, es posible invocar el compilador dándole como entrada sólo ese fichero fuente. La compilación de un fichero fuente produce un fichero objeto que contiene la traducción del código C+- a instrucciones de máquina, los ficheros fuente en C+- tienen la extensión .cpp y los ficheros objeto la extensión .o.

Módulo principal:

          Cuando se descompone un programa en C+- en varios módulos uno de ellos ha de ser el programa principal o módulo principal. Este módulo será el que contenga la función main().

Módulos no principales:

          Los módulos de la aplicación que no contienen una función main() no permiten generar un programa ejecutable por sí solos. Los elementos que contienen están destinados a ser usados por el programa principal u otros módulos.

La distinción entre los elementos públicos y los privados se hace repartiendo el código del módulo en dos ficheros fuente separados: un fichero de interfaz o fichero de cabecera y un fichero de implementación.

          El fichero de interfaz tendrá la extensión .h y el de implementación la extensión .cpp.

          La directiva #include sirve para hacer referencia a un fichero fuente desde otro, y tiene como parámetro el nombre del fichero físico incluyendo la extensión.

Uso de módulos:

          Para usar los elemento públicos definidos en un módulo hay que incluir la interfaz de ese módulo en el código donde se vaya a utilizar,. Esto se consigue con la directiva #include. La novedad ahora es que los nombres de los ficheros de la propia aplicación debes escribirse entre comillas “ “ y no entre ángulos < >.

Declaración y definición de elementos públicos:

          En la declaración de un elemento hay que especificar lo necesario para el compilador pueda compilar correctamente el código que usa dicho elemento. En la definición de un elemento hay que especificar lo necesario para que el compilador genera el código del propio elemento.

          Los tipos y constantes se especifican totalmente en el fichero interfaz. No hay declaración y definición separadas. Las variables se definen de la manera habitual en el fichero de implementación, incluyendo la especificación de valor inicial en su caso. Con ello el compilador reserva espacio para dicha variable en el módulo que la define. En el fichero interfaz se pone además una declaración que indica el tipo y nombre de la variable, sin indicar el valor inicial, y precedida de la palabra clave extern. Esta declaración permite al compilador generar código de las sentencias que usan dicha variable en otros módulos sin reservar espacio para ella, ya que formará parte efectiva del código del módulo que la define. La conexión entre las referencias a la variable y su ubicación real se resuelve durante la fase de montaje, posterior a la compilación. Los subprogramas se definen de la manera habitual en el fichero de implementación y permiten al compilador generar el código objeto del subprograma. En el fichero de interfaz se pone además una declaración en forma de prototipo o cabecera de subprograma sólo con el tipo, nombre y argumentos. Esta cabecera permite al compilador generar el código de las sentencias de llamada al subprograma. La conexión entre las llamadas al subprograma y su código real se resuelve durante la fase de montaje, posterior a la compilación.

Conflicto de nombre en el ámbito global:

          Es posible especificar elementos en el ámbito más externo que sólo sean visibles en el fichero fuente donde se definen. Para ello basta poner la palabra clave static delante de la definición del elemento.

Unidades de compilación en C+-:

          El módulo principal: programa.cpp

          El fichero de interfaz de un módulo: modulo.h

          El fichero de implementación de un módulo: modulo.cpp

Implementación de abstracciones como módulos:

          En la mayoría de los casos los tipos abstractos de datos identificados en una aplicación son buenos candidatos para ser codificados como módulos independientes, y lo mismo ocurre con las abstracciones funcionales de cierta complejidad. Por lo tanto el desarrollo basado en abstracciones lleva implícita una posible descomposición natural del programa en módulos.

Dependencias entre ficheros:

          Las relaciones de uso entre módulos se corresponden, en principio, con las directivas #include usadas en un fichero fuente para hacer visibles los elementos de otro, y que pueden aparecer en el fichero .cpp y/o en el .h.

          Debemos tener cuidado pues si no se toman precauciones el preprocesador incluirá el código dos veces y se tendrán errores por duplicación. La directiva #pragma once sirve para evitar duplicidades.

La modificación del código de un programa para reorganizarlo sin cambiar su funcionalidad se denomina refactorización.

Reutilización de módulos:

          Los módulos que definen abstracciones relacionadas entre sí pueden agruparse en una biblioteca o librería que se pone a disposición de quienes desarrollan aplicaciones en un campo determinado

Ejemplo de TAD

Aquí os dejo un ejemplo de tipo abastracto de dato TAD, espero que os sirva. Está todo el código fuente y compila perfectamente, sólo tenéis que copiarlo y listo:

Fichero Interfaz hola.h

#pragma once
typedef struct TipoModulo1{
  void ImprimirHola();
};

Fichero Implementación hola.cpp

#include <stdio.h>
#include "interfaz.h"
void TipoModulo1::ImprimirHola(){
  printf("Hola");
}

Fichero Principal HolaMundo.cpp

#include <stdio.h>
#include "interfaz.h"
TipoModulo1 Modulo1;
int main(){
  Modulo1.ImprimirHola();
}

Tipos Abstractos de datos TAD

Un tipo abstracto de datos (TAD) es una agrupación de una colección de valores y una colección de operaciones de manipulación, podemos definirlos de varias maneras:

Definición de tipos abstractos como tipos registro (struct):

          Los campos de datos sirven para almacenar el contenido de información del dato abstracto, los subprogramas permiten definir operaciones sobre esos datos, la posibilidad de declarar ciertos elementos como privados permite ocultar detalles de implementación, y dejar visible sólo la interfaz del tipo abstracto.

Ocultación:

          Para que un tipo sea realmente abstracto haría falta que los detalles de implementación no fueran visibles. Para permitir esta ocultación los tipos struct admiten la posibilidad de declarar ciertos elementos componentes como privados, usando la palabra clave prívate para delimitar una zona de declaraciones privadas dentro de la estructura.

Desarrollo por refinamiento basado en abstracciones:

          Para realizar un refinamiento basado en abstracciones podemos considerar el dato como un dato elemental, y usar directamente un tipo predefinido del lenguaje para representarlo, considerar el dato como un dato complejo, y descomponerlo en otros más sencillos (como registro, unión o formación), considerar el dato como un dato abstracto y especificar su interfaz, dejando para más adelante los detalles de su implementación.