¿QUÉ ES LA HERENCIA EN PROGRAMACIÓN ORIENTADA A OBJETOS? (Emilio Ampuero)

Muchas veces distintos objetos comparten campos y métodos que hacen aproximadamente lo mismo (por ejemplo almacenar y devolver un nombre del ámbito humano con el que se designa al objeto, como el título de un álbum de música, el título de un libro, el título de una película, etc.).

Por ejemplo en un proyecto que utilice objetos Taxi y objetos Autobus podríamos encontrarnos algo así:

Para una aplicación de gestión de una empresa de transporte que tenga entre sus vehículos taxis y autobuses podríamos tener otra clase denominada FlotaCirculante donde tendríamos posibilidad de almacenar ambos tipos de objeto (por ejemplo taxis en un ArrayList y autobuses en otro ArrayList) como reflejo de los vehículos que se encuentran en circulación en una fecha dada. Esas listas conllevarían una gestión para añadir o eliminar vehículos de la flota circulante, modificar datos, etc. resultando que cada una de las listas necesitaría un tratamiento o mantenimiento.

Si nos fijamos en el planteamiento del problema, encontramos lo siguiente:

a) La definición de clases nos permite identificar campos y métodos que son comunes a Taxis y Autobuses. Si implementamos ambas clases tal y como lo venimos haciendo, incurriremos en duplicidad de código. Por ejemplo si el campo matricula es en ambas clases un tipo String, el código para gestionar este campo será idéntico en ambas clases.

b) La definición de clases nos permite identificar campos y métodos que difieren entre una clase y otra. Por ejemplo en la clase Taxi se gestiona información sobre un campo denominado numeroDeLicencia que no existe en la clase Autobus.

c)  Conceptualmente podemos imaginar una abstracción que engloba a Taxis y Autobuses: ambos podríamos englobarlos bajo la denominación de “Vehículos”. Un Taxi sería un tipo de Vehiculo y un Autobus otro tipo de Vehiculo.

d) Si la empresa añade otros vehículos como minibuses, tranvías, etc. manteniendo la definición de clases tal y como la veníamos viendo, seguiríamos engrosando la duplicidad de código. Por ejemplo, un minibús también tendría matrícula, potencia… y los métodos asociados.

La duplicidad de código nos implicará problemas de mantenimiento. Por ejemplo inicialmente tenemos una potencia en caballos y posteriormente queremos definirla en kilowatios. O tenemos simplemente que modificar el código de un método que aparece en distintas clases. El tener el código duplicado nos obliga a tener que hacer dos o más modificaciones en sitios distintos. Pueden ser dos modificaciones, tres, cuatro o n modificaciones dependiendo del número de clases que se vieran afectadas, y esto a la larga genera errores al no ser el mantenimiento razonable.

En la clase FlotaCirculante también tendremos seguramente duplicidades: por un lado un ArrayList de taxis y por otro un ArrayList de autobuses, por un lado una operación de adición de taxis y otra operación de adición de autobuses, por un lado una operación para mostrar los elementos de la lista de taxis y otra para los elementos de la lista de autobuses…

¿No sería más razonable, si una propiedad o método va a ser siempre común para varios tipos de objetos, que estuviera localizada en un sitio único del que ambos tipos de objeto “bebieran”? En los lenguajes con orientación a objetos la solución a esta problemática se llama herencia. La herencia es precisamente uno de los puntos clave de este tipo de lenguajes. 

La herencia nos permite definir una clase como extensión de otra: de esta manera decimos “la clase 1.1 tiene todas las características de la clase 1 y además sus características particulares”. Todo lo que es común a ambas clases queda comprendido en la clase “superior”, mientras lo que es específico, queda restringido a las clases “inferiores”. En nuestro ejemplo definiríamos una clase denominada Vehiculo, de forma que la clase Taxi tuviera todas las propiedades de la clase Vehiculo, más algunas propiedades y métodos específicos. Lo mismo ocurriría con la clase Autobus y otras que pudieran “heredar” de Vehiculo. Podríamos seguir creando clases con herencia en un número indefinido: tantas como queramos. Si piensas en el API de Java, hay cientos de clases que heredan de clases jerárquicamente superiores como la clase Object. En un proyecto propio, podremos tener varias clases que hereden de una clase común.

                      Esquema básico de herencia

Otro ejemplo: para la gestión de un centro educativo, podemos definir la clase Persona que comprende los campos y métodos comunes a todas las personas. Luego podremos definir la clase Estudiante, que es extensión de Persona, y comprende los campos y métodos de la clase superior, más algunos específicos. También podrían heredar de Persona la clase Profesor, la clase Director, la clase JefeDeEstudios, la clase PersonalAdministrativo, etc.

La primera aproximación a la herencia en Java la plantearemos para plasmar todo lo que hemos discutido en párrafos anteriores: en vez de definir cada clase por separado con operaciones o campos duplicados en cierta medida, definiremos una clase “padre” que contendrá todas las cosas que tengan en común otras clases. Luego definiremos las otras clases “hijo” como extensión de la clase padre, especificando para ellas únicamente aquello que tienen específico y distinto de la clase padre. Una característica esencial de la herencia es que permite evitar la duplicidad de código: aquello que es común a varias clases se escribe solo una vez (en la clase padre). La duplicidad de información, ya sea código o datos, es algo que por todos los medios hay que tratar de evitar en los sistemas informáticos por ser fuente de errores y de problemas de mantenimiento.

Si nos remitimos al esquema básico de herencia donde hemos representado las clases Vehiculo, Taxi y Autobus, la clase Vehiculo diremos que actúa como clase padre de las clases Taxi y Autobus. Vehiculo recogería todo aquello que tienen o hacen en común taxis y autobuses. Aunque aquello que tienen en común se agrupa, tanto Taxi como Autobus tienen sus campos o métodos específicos.

Que una clase derive de otra en Java se indica mediante la palabra clave “extends”. Por eso muchas veces se usa la expresión “esta clase es extensión de aquella otra”. En los diagramas de clase la herencia se representa con una flecha de punta vacía. El aspecto en BlueJ sería algo así:

Este diagrama refleja que la clase FlotaCirculante usa a la clase Vehiculo, mientras que las clases Taxi y Autobus heredan de la clase Vehiculo (son extensión de la clase Vehiculo). Podemos decir que la clase hijo extiende (hace más extensa) a la clase padre. Una clase de la que derivan otras se denomina clase padre, clase base o superclase. Las clases que heredan se denominan clases derivadas, clases hijos o subclases. A partir de ahora los términos superclase y subclase son los que usaremos con más frecuencia. Una subclase podrá tener un acceso “más o menos directo” a los campos y métodos de la superclase en función de lo que defina el programador, como veremos más adelante. Para referirnos a la herencia también se usa la terminología “es un”. En concreto decimos que un objeto de la subclase es un objeto de la superclase, o más bien en casos concretos, que un Taxi es un Vehiculo, o que un Estudiante es una Persona. Sin embargo, al revés esto no es cierto, es decir, un Vehiculo no es un Taxi, ni una Persona es un Estudiante.

Dos subclases que heredan de una clase no deben tener información duplicada. Esto se consideraría un mal diseño. La información común debe estar en una superclase.

Polimorfismo en JAVA (Emilio Ampuero)

Polimorfismo en JAVA (Emilio Ampuero)

El polimorfismo consiste en obtener un mismo método con diferentes funciones, es decir, suponiendo que tengamos una clase Saludo con el método Saludo el cual sería su constructor, pero en este caso tendríamos varios constructores pero siempre siguiendo las reglas de independencia en cuestión a los parámetros de cada constructor para que así puedan diferenciarse uno de otro, sin embargo cada uno tendrá diferentes procesos internos en sí mismo.

CREACIÓN DEL POLIMORFISMO

Primero crearemos una clase ajena a la clase main la cual denominaremos Saludo. Dentro de saludo crearemos un atributo llamado “MensajeSaludo” de la siguiente manera.

String MensajeSaludo;

Posteriormente pasamos a crear los constructores con diferentes atributos y funciones lo cual vendría a ser el polimorfismo de la clase Saludo.

public Saludo(){
        MensajeSaludo="Hola Amigo";
}
public Saludo(String Palabra){
        MensajeSaludo=Palabra;
}
public Saludo(String Palabra, String Nombre){
        MensajeSaludo=Palabra.concat(" ").concat(Nombre);
}

Realizado esto podríamos instanciar a los diferentes constructores de la clase Saludo en nuestro main principal o donde lo requiramos. En este caso usaremos el polimorfismo en nuestro main.

INSTANCIANDO NUESTRO POLIMORFISMO

Para usar el primer constructor de nuestro polimorfismo (El que no cuenta con atributos) instanciamos de la siguiente manera:

Saludo x=new Saludo();

Para el segundo sería de la misma pero almacenando en otra variable:

Saludo y=new Saludo("Hola Kevin");

Y luego tendríamos el tercero:

Saludo z=new Saludo("Hola", "Kevin Arnold");

IMPRESIÓN DE CADA CONSTRUCTOR

Para poder imprimir en pantalla el atributo que fue asignado por los diferentes constructores de nuestra clase Saludo, debemos introducir el siguiente código:

System.out.println(x.MensajeSaludo);
System.out.println(y.MensajeSaludo);
System.out.println(z.MensajeSaludo);

Donde indicamos con nuestras variables “x”, “y” y “z” los diferentes constructores (Polimorfismo de la clase Saludo). Y el “MensajeSaludo” sería el atributo que tomó diferentes valores según el polimorfismo asignado a cada variable de la clase Saludo.

Explcacion de "try /catch" en JAVA (Emilio ampuero)

Sintaxis del Bloque try/catch:

try { // Código que pueda generar Errores ("Exception's") } catch(Tipo1 id1) { // Manejar "Exception's" para la Clase Tipo1 } catch(Tipo2 id2) { // Manejar "Exception's" para la Clase Tipo2 } catch(Tipo3 id3) { // Manejar "Exception's" para la Clase Tipo3 }

La primer sección del Bloque es iniciada con el vocablo try y una llave ({ ) que indica el principio de la zona protegida, dentro de esta primer sección es colocado todo código que pueda generar algún tipo de error, al terminar esta sección se define un grupo de estructuras con el elemento catch.

Como se puede observar en la ilustración, cada vocablo catch es seguido de un paréntesis que contiene una Clase así como una referencia, estos son considerados los Datos de Entrada para cada sección catch; el tipo de Clases definidas dentro de cada sección catch depende del numero de "Exceptions" que pueden ser generadas por el programa; lo anterior permite definir un numero ilimitado de "Exceptions" cada uno con su propio código para manejar el error.

Para todo Bloque try/catch debe ser definida al menos una sección catch; si son definidos más de dos Clases para errores ("Exceptions") estas deben ser declaradas de más a menos especifica, siendo la menos especifica la Clase java.lang.Throwable; es de esta Clase que son Heredadas ("Inherited") todo "Exception" en Java, esto será descrito en la siguiente sección de este curso.

C++ (Emilio Ampuero)

C++ es un lenguaje de programacion diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programacion generica, que se sumaron a los paradigmas de programacion extructurada y POO. Por esto se suele decir que el C++ es un lenguaje deprogramacion multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.

Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear nuevos tipos que se comporten como tipos fundamentales.

El nombre C++ fue propuesto por Rick Masciti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

Un ejemplo de programa

A continuación se cita un programa de ejemplo Hola mundo escrito en C++:

/* Esta cabecera permite usar los objetos que encapsulan los descriptores stdout 
y stdin: cout(<<) y cin(>>)*/
#include 

using namespace std;

int main()
{
   cout << "Hola mundo" << endl;
   cin.get();
}

Al usar la directiva #include se le dice al compilador que busque e interprete todos los elementos definidos en el archivo que acompaña la directiva (en este caso,iostream). Para evitar sobrescribir los elementos ya definidos al ponerles igual nombre, se crearon los espacios de nombres o namespace del singular en inglés. En este caso hay un espacio de nombres llamado std, que es donde se incluyen las definiciones de todas las funciones y clases que conforman la biblioteca estándar de C++. Al incluir la sentencia using namespace std le estamos diciendo al compilador que usaremos el espacio de nombres std por lo que no tendremos que incluirlo cuando usemos elementos de este espacio de nombres, como pueden ser los objetos cout y cin, que representan el flujo de salida estándar (típicamente la pantalla o una ventana de texto) y el flujo de entrada estándar (típicamente el teclado).

La definición de funciones es igual que en C, salvo por la característica de que si main no va a recoger argumentos, no tenemos por qué ponérselos, a diferencia de C, donde había que ponerlos explícitamente, aunque no se fueran a usar. Queda solo comentar que el símbolo << se conoce como operador de inserción, y grosso modo está enviando a cout lo que queremos mostrar por pantalla para que lo pinte, en este caso la cadena "Hola mundo". El mismo operador << se puede usar varias veces en la misma sentencia, de forma que gracias a esta característica podremos concatenar el objeto endl al final, cuyo resultado será imprimir un retorno de línea.

Por último tomaremos una secuencia de caracteres del teclado hasta el retorno de línea (presionando ENTER), llamando al método get del objeto cin.

Break & Continue(while)- Benjamin Pacheco

Break & Continue

Las instrucciones repetitivas for y while, cuentan con dos instrucciones que permiten abandonar la ejecución del bloque de instrucciones antes de su finalización. Estas instrucciones son: break y continue. Tambien se le conoce como salida forzada de un bucle

#Break: Su uso, ademas de la instruccion Switch también se puede extender a las instrucciones repetitivas. En estas, la utilización de break provoca una salida forzada del bucle, continuando la ejecución del programa en la primera sentencia situada después del mismo.

Estructura de la instruccion Break:

for( int i = 0 ; ; i++){
  System.out.println(i);
          if ( i == 30 ){
                System.out.println("i es igual a 30 | Salir ");
                break;
             }
   }
   System.out.println("1ª sentencia después del bucle");

#Continue:La instrucción continue provoca que el bucle detenga la iteración actual y pase, en el caso del for, a ejecutar la instrucción de incremento o en el caso de while, a comprobar la condición de entrada.

Estructura de la instruccion Continue:

int i = 0;
        while ( i < 10 ) 
        {
          if ( i == 5 ){
           //continue;
           //break;
          }
          System.out.println("i: " + i );
          i++;
        }

Try-Catch-Finally- Benjamin Pacheco

Try – Catch – Finally -Benjamín Pacheco

Instruccion Try – Catch – Finally 

El control de flujo de un programa Java sabemos hasta ahora que se lleva a cabo con sentencias del tipo if, while, for, return, break, etc… Estas sentencias forman un conjunto de palabras reservardas que determinan cierta funcionalidad. Pues bien, ninguna de ellas tiene en cuenta que se puedan producir errores en tiempo de ejecución de un programa y por tanto Java necesita de un conjunto de palabras nuevas para tener en cuenta que cualquier código puede fallar o ser mal interpretado en tiempo de ejecución El uso de try – catch – finally corresponde a la captura de errores. Estas instrucciones se usan en ejercicios tales como divisiones por cero, cambio de tipo de datos, lectura de archivos, conexiones con bases de datos, entre otras.

Estructura de Try – Catch – Finally:

try
{
 //Instrucciones que pueden producir una excepción
}
catch(excepción variable)
{
 //Tratamiento de la excepción
}
finally
{
 //Instrucciones de ultima ejecución 
}

Definicion de las instrucciones:

#TRY: Todo el código que vaya dentro de esta sentencia será el código sobre el que se intentará capturar el error si se produce y una vez capturado hacer algo con él.

#CATCH: Conjunto de instrucciones necesarias o de tratamiento del problema capturado con el bloque try anterior. Es decir, cuando se produce un error o excepción en el código que se encuentra dentro de un bloque try, pasa directamente a ejecutar el conjunto de sentencias que hay en el bloque catch.

#FINALLY: Es un bloque donde se puede definir un conjunto de instrucciones necesarias tanto si se produce error o excepción como si no y que por tanto se ejecuta siempre.

Bases de Datos- Benjamin Pacheco

Bases de Datos-Benjamín Pacheco

Bases de Datos

Es una colección de datos interrelacionados y un conjunto de programas para acceder a dichos datos. El objetivo principal de SGBD es proporcionar una forma de almacenar y recuperar la información de la base de datos de manera que sea tanto practica como eficiente.

  Modelos de los datos 

Es una colección de herramientas conceptuales para describir los datos, las relaciones, la semántica y las restricciones. Existen varios tipos de modelo de datos:

             >>Modelo Entidad-Relación 
             >>Modelo Relacional (tablas) 
             >>Modelo de datos relacional orientado a objetos
             >>Modelo de datos orientado a objetos
       

 Lenguaje de bases de datos 

Un sistema de bases de datos proporciona un lenguaje de definición de datos para especificar el esquema de la base de datos y un lenguaje de manipulación de datos para expresar las consultas a la base de datos y las modificaciones.