1.

Historia de la programación orientada a objetos

Las ideas básicas de la orientación a objetos nacen a principios de los años 60 en la universidad de
Noruega. Un equipo dirigi-do por el Dr. Nygaard se dedicaba a desarrollar sistemas infor-máticos
para realizar simulaciones de sistemas físicos como simular el funcionamiento y obtener el
rendimiento de un motor. La dificultad en la que se encontraban era doble. Por un lado los
programas eran muy complejos y, por otro, forzosamente tenian que ser muy modificados. Este
segundo punto era especialmente problemático, ya que la razón de ser de los programas era el
cambio y no sólo se requerían varias iteraciones para obtener un producto con el rendimiento
deseado, sino que muchas veces se querían obtener diversas alternativas viables cada una con sus
ventajas e inconvenientes.

La solución que idearon fue diseñar el programa paralelamente al objeto físico. Es decir, si el objeto
físico tenía cien componentes, el programa también tendría cien módulos, uno por cada pieza.
Partiendo el programa de esta manera, había una total correspondencia entre el sistema físico y el
sistema informático. Así, cada pieza física tenía su abstracción informática en un módulo. De la
misma manera que los sistemas físicos se comunican enviándose señales, los módulos informáticos
se comunicarían enviándose mensajes.

Este enfoque resolvió los dos problemas planteados. Primeramente, ofrecía una forma natural de
partir un programa muy complejo y, en segundo lugar, el mantenimiento pasaba a ser controlable.
El primer punto es obvio ya que, al partir el programa en unidades informáticas paralelas a las
físicas, la descomposición es automática. El segundo punto también se resuelve ya que, a cada
iteración de simulación, el analista querrá cambiar o bien piezas enteras o bien el comportamiento
de alguna pieza. En ambos casos la localización de los cambios está perfectamente clara y su
alcance se reduce a un componente, siempre y cuando el interfaz del mismo no cambie. Por
ejemplo, si se estuviese simulando un motor o coche, puede que se quisiera modificar el delco
utilizado en la simulación anterior. Si el nuevo delco tuviera la misma interfaz (mismos inputs y
outputs) o se cambiase sólo su comportamiento interno, nada del sistema (fuera del delco) estaría
afectado por el cambio.

Pero, poco a poco, fue obteniendose otro beneficio muy importante, que es la razón principal por la
que la industria informática se ha abocado a la orientación a objetos. Se trata de la reusabilidad. En
el proceso de construcción de un programa se obtienen piezas para futuros programas. Avanzando
algunas cifras, se puede indicar que los niveles de reutilización de software pasan del 5-15% en
centros no orientados a objetos, a niveles por encima del 80%.

Para implementar estas ideas lo que se hizo fue crear un lenguaje para darle soporte, Simula-67, que
continua utilizándose actualmente.

El siguiente paso se da en los años 70 en los Estados Unidos. Xerox tiene un centro de investigación
en Plo Alto, donde trabajan en conceptos que puedan convertirse en productos industriales al cabo
de 10 a 20 años. Así pues, en aquellos años contrataron a un joven llamado Alan Kay para que
llevase a término las ideas que proponía en su tesis doctoral, la propuesta de construcción de un
ordenador llamado Dynabook, adecuado para ser utilizado por niños. El ordenador no tenía teclado,
la pantalla era sensible al tacto y la mayor parte de la comunicación era gráfica. Al desarrollar este
proyecto se inventó el 'mouse' y los entornos gráficos. Al volver a encontrarse con una progra-
mación compleja y experimental, como en el caso de Nygaard, decidieron crear un entorno y
lenguaje llamado Smalltalk.
 Smalltalk tuvo una gran difusión y cuando en los años 80 en ATT-Bell quisieron crear un sucesor al
lenguaje C, incorporaron las principales ideas de Smalltalk y de Simula, creando el lenguaje C++.
Puede afirmarse que se debe a este último la gran extensión de los conceptos de la orientación a
objetos.

Conviene subrayar que el desarrollo que hemos descrito se refiere sólo a la evolución que ha tenido
la orientación a objetos en el mundo de la ingeniería del software. Ha existido un desarrollo paralelo
de los mismos conceptos en el mundo de la inteligencia artificial, donde el lenguaje CLOS, una
variante de Lisp orientada a objetos, está enormemente extendido.

http://www2.ati.es/novatica/1995/mar-abr/n114obje.html

2. Ventajas y desventajas de la programación orientada a objetos

VENTAJAS DESVENTAJAS

 Facilidad de mantenimiento y modificación de los

objetos existentes.  Cambio en la forma de pensar de la
 Una estructura modular clara se puede obtener, la programación tradicional a la orientada a
cual no revelará el mecanismo detrás del diseño objetos.
 Se acopla bien a la utilización de bases de datos,  La ejecución de programas orientados a
debido a la correspondencia entre las estructuras. objetos es más lenta.
 Todo el código se encuentra en un solo lugar  La necesidad de utilizar bibliotecas de clases
 Reusabilidad Cuando hemos diseñado obliga a su aprendizaje y entrenamiento.
adecuadamente las clases, se pueden usar en  Los objetos requieren una extensa
distintas partes del programa y en numerosos documentación.
proyectos.  Para leer, modificar, o hacerles algo
 Mantenibilidad. Debido a la sencillez para abstraer simplemente; en algunos programas debes
el problema, los programas orientados a objetos realizar un paso extra para realizar estas
son más sencillos de leer y comprender, pues nos acciones.
permiten ocultar detalles de implementación
dejando visibles sólo aquellos detalles más
relevantes.
 Modificabilidad. La facilidad de añadir, suprimir o
modificar nuevos objetos nos permite hacer
modificaciones de una forma muy sencilla.
 Fiabilidad. Al dividir el problema en partes más
pequeñas podemos probarlas de manera
independiente y aislar mucho más fácilmente los
posibles errores que puedan surgir.
 3. Componentes

Que son: Es una clase de uso específico, lista para usar, que puede ser configurada o
utilizada de forma visual, desde el entorno de desarrollo.
La principal diferencia, respecto a una clase normal, es que la mayor parte del trabajo lo
podemos hacer de forma visual, con el ratón y ajustando las opciones que se nos ofrece en
nuestro entorno.

Visuales: Son aquellos que, al utilizarlos, muestran algún elemento (o dibujo) en la pantalla
y es el usuario de nuestros programas el que interactúa con él. El componente es el
principal responsable de dibujar en la pantalla lo que sea oportuno, dependiendo de su
estado, del valor de sus atributos, etc. Hay muchos componentes de este tipo, como pueden
ser los botones (TButton), etiquetas de texto (TLabel), formas (TShape), etc.

No Visuales: Son aquellos que no aparecen en la ventana, y se insertan en un formulario

para que el programador los utilice. Son más fáciles de programar que los componentes
visuales, ya que no tienen ningún tipo de interfaz gráfico. Ejemplos de componentes no
visuales podrían ser un temporizador (TTimer), una tabla (TTable) o una conexión a base
de datos (TConnection, TSQLConnection, etc.).

Todos los componentes tienen propiedades, eventos, métodos y atributos

 Propiedades: Son datos públicos del componente, muy parecidas a los atributos de
una clase, aunque se accede a ellas a través de dos métodos: un método para leer su
valor, y otro para modificarlo. Existen propiedades de sólo lectura, en las que
podemos consultar pero no modificar su valor, y propiedades de sólo escritura.
 Eventos: Son funciones del componente, que se ejecutarán automáticamente
cuando ocurra “algo importante”. Un programador puede poner el código que
quiera en el evento, para así poder hacer una acción cuando ese “algo importante”
ocurra.
 Métodos: Son funciones, que permiten realizar acciones. Normalmente, se utilizan
métodos para dos tareas distintas: realizar algo importante (como repintar en
pantalla, cambiar el foco o algo así), o para establecer el valor de los atributos
internos, haciendo algún tipo de comprobación previa. Como las propiedades
pueden ser leídas o escritas a través de métodos, a veces es equivalente la llamada a
un método y el cambio de una propiedad
 Atributos: Tienen la misma misión que en programación orientada a objetos, es
decir: almacenar datos internos al objeto (o clase). En el maravilloso mundo de los
componentes, los atributos siempre son internos y de uso privado, y debemos
utilizar las propiedades para que un programador pueda leer o establecer un dato.

1. https://msdn.microsoft.com/es-co/library/bb972232.aspx
2. http://novella.mhhe.com/sites/dl/free/8448156315/540597/Cap_Muestra_Joyanes_8448156
315.pdf
4. Lenguajes de Programación: Los lenguajes de programación orientadas a objetos son
lenguajes dinámicos en los que estos objetos se pueden crear y modificar sobre la marcha.
Esta programación orientada a objetos (POO) tomo auge a mediados de los años ochenta
debido a la propagación de las interfaces gráficas de usuarios, para lo que los lenguajes de
programación orientados a objetos están especialmente dotados.
Los principales lenguajes de programación orientados a objetos son:
Ada, C++, C#, VB.NET, Clarion, Delphi, Eiffel, Java, Lexico (en castellano), Objective-C,
Ocaml, Oz, PHP, PowerBuilder, Python, Ruby y Smalltalk.

No todos estos lenguajes de programación orientados a objetos son específicamente

orientados a objetos. Sino que algunos de ellos se le han añadido extensiones orientadas a
objetos.
Un nuevo paso en los lenguajes de programación es la Programación orientada a aspectos
(POA). Actualmente esta en fase de desarrollo, pero cada vez atrae a más investigadores y
empresas de todo el mundo.

Los Principales Lenguaje de Programación:

http://www.larevistainformatica.com/lenguajes-programacion-orientada-
objetos.htm

5. UML: El Lenguaje Unificado de Modelado (UML) fue creado para forjar un lenguaje de
modelado visual común y semántica y sintácticamente rico para la arquitectura, el diseño y
la implementación de sistemas de software complejos, tanto en estructura como en
comportamiento. UML tiene aplicaciones más allá del desarrollo de software, p. ej., en el
flujo de procesos en la fabricación.
 Es comparable a los planos usados en otros campos y consiste en diferentes tipos de
diagramas. En general, los diagramas UML describen los límites, la estructura y el
comportamiento del sistema y los objetos que contiene.
UML no es un lenguaje de programación, pero existen herramientas que se pueden usar
para generar código en diversos lenguajes usando los diagramas UML. UML guarda una
relación directa con el análisis y el diseño orientados a objetos
 UML y su función en el modelado y diseño orientado a objetos: Hay muchos
paradigmas o modelos para la resolución de problemas en la informática, que es el estudio
de algoritmos y datos. Hay cuatro categorías de modelos para la resolución de problemas:
lenguajes imperativos, funcionales, declarativos y orientados a objetos (OOP). En los
lenguajes orientados a objetos, los algoritmos se expresan definiendo 'objetos' y haciendo
que los objetos interactúen entre sí. Esos objetos son cosas que deben ser manipuladas y
existen en el mundo real. Pueden ser edificios, artefactos sobre un escritorio o seres
humanos. 
Los lenguajes orientados a objetos dominan el mundo de la programación porque modelan
los objetos del mundo real. UML es una combinación de varias notaciones orientadas a
objetos: diseño orientado a objetos, técnica de modelado de objetos e ingeniería de software
orientada a objetos.
UML usa las fortalezas de estos tres enfoques para presentar una metodología más
uniforme que sea más sencilla de usar. UML representa buenas prácticas para la
construcción y documentación de diferentes aspectos del modelado de sistemas de software
y de negocios

EJEMPLO:

https://www.lucidchart.com/pages/es/que-es-el-lenguaje-unificado-de-modelado-uml
 6. EJEMPLO CODIGO DE FUENTE:
Haz una clase llamada Password que siga las siguientes condiciones:

 Que tenga los atributos longitud y contraseña . Por defecto, la longitud sera de 8.

 Los constructores serán los siguiente:

 Un constructor por defecto.

 Un constructor con la longitud que nosotros le pasemos. Generara una contraseña aleatoria
con esa longitud.
 Los métodos que implementa serán:
 esFuerte(): devuelve un booleano si es fuerte o no, para que sea fuerte debe tener
mas de 2 mayúsculas, mas de 1 minúscula y mas de 5 números.
 generarPassword():  genera la contraseña del objeto con la longitud que tenga.

 Método get para contraseña y longitud.

 Método set para longitud.

Ahora, crea una clase clase ejecutable:

 Crea un array de Passwords con el tamaño que tu le indiques por teclado.

 Crea un bucle que cree un objeto para cada posición del array.

 Indica también por teclado la longitud de los Passwords (antes de bucle).

 Crea otro array de booleanos donde se almacene si el password del array de Password es o
no fuerte (usa el bucle anterior).

 Al final, muestra la contraseña y si es o no fuerte (usa el bucle anterior). Usa este simple

formato:
contraseña1 valor_booleano1

contraseña2 valor_bololeano2

SOLUCION:

Clase Password

/**
 * Clase Password
 *
 * Contiene una contraseña y una longitud
 *
 * @author Fernando
 * @version 1.0
 */
public class Password {
  
    //Constantes
  
    /**
     * Longitud por defecto
     */
    private final static int LONG_DEF=8;
  
    //Atributos
  
    /**
     * Longitud de la contraseña
     */
    private int longitud;
    /**
     * caracteres de la contraseña
     */
    private String contraseña;
  
    //Metodos publicos
  
    /**
     * Devuelve la longitud
     * @return longitud de la contraseña
     */
    public int getLongitud() {
        return longitud;
    }
  
    /**
     * Modifica la longitud de la contraseña
     * @param longitud a cambiar
     */
    public void setLongitud(int longitud) {
        this.longitud = longitud;
    }
  
    /**
     * Devuelve la contraseña
     * @return contraseña
     */
    public String getContraseña() {
        return contraseña;
    }
  
    /**
     * Genera una contraseña al azar con la longitud que este definida
     * @return contraseña
     */
    public String generaPassword (){
        String password="";
        for (int i=0;i<longitud;i++){
            //Generamos un numero aleatorio, segun este elige si añadir una minuscula, mayuscula o
numero
            int eleccion=((int)Math.floor(Math.random()*3+1));
  
            if (eleccion==1){
                char minusculas=(char)((int)Math.floor(Math.random()*(123-97)+97));
                password+=minusculas;
            }else{
                if(eleccion==2){
                    char mayusculas=(char)((int)Math.floor(Math.random()*(91-65)+65));
                    password+=mayusculas;
                }else{
                    char numeros=(char)((int)Math.floor(Math.random()*(58-48)+48));
                    password+=numeros;
                }
            }
        }
        return password;
    }
  
    /**
     * Comprueba la fortaleza de la contraseña
     * @return
     */
    public boolean esFuerte(){
        int cuentanumeros=0;
        int cuentaminusculas=0;
        int cuentamayusculas=0;
        //Vamos caracter a caracter y comprobamos que tipo de caracter es
        for (int i=0;i<contraseña.length();i++){
                if (contraseña.charAt(i)>=97 && contraseña.charAt(i)<=122){
                    cuentaminusculas+=1;
                }else{
                    if (contraseña.charAt(i)>=65 && contraseña.charAt(i)<=90){
                        cuentamayusculas+=1;
                }else{
                    cuentanumeros+=1;
                    }
                }
            }
            //Si la constraseña tiene mas de 5 numeros, mas de 1 minuscula y mas de 2 mayusculas
            if (cuentanumeros>=5 && cuentaminusculas>=1 && cuentamayusculas>=2){
            return true;
        }else{
            return false;
        }
    }
  
    //Constructores
    /**
     * Crea una contraseña al azar
     */
    public Password (){
        this(LONG_DEF);
    }
  
    /**
     * La contraseña sera la pasada por parametro
     * @param longitud
     */
    public Password (int longitud){
        this.longitud=longitud;
        contraseña=generaPassword();

, indicamos si es fuerte y mostramos la contraseña y su fortaleza.

        for(int i=0;i<listaPassword.length;i++){
            listaPassword[i]=new Password(longitud);
            fortalezaPassword[i]=listaPassword[i].esFuerte();
            System.out.println(listaPassword[i].getContraseña()+" "+fortalezaPassword[i]);
        }
    }
  
}

Laboratorio 2.1.4.6 ............................................................................3 a 9.

Laboratorio 2.2.3.4 ........................................................................10 a 17.

Laboratorio 3.2.3.4.........................................................................18 a 23.

Laboratorio 3.2.4.6.........................................................................24 a 30.

Laboratorio 4.1.2.4.........................................................................30 a 33.

Conclusiones..........................................................................................34.

Bibliografía............................................................................................35.
 Programación orienta a Objetos

Se define como UML

Componentes

No es un lenguaje de programación,
pero existen herramientas que se
pueden usar para generar código en
Un paradigma de programación q diversos lenguajes usando los
ue usa objetos y sus Propiedades: Son diagramas UML. UML guarda una
interacciones, para datos públicos del relación directa con el análisis y el
diseñar aplicaciones y programas componente diseño orientados a objetos
informáticos

Eventos: Son
funciones del
componente, que se
Historia
ejecutarán
automáticamente

 Nace a principios de los

años 60 en la universidad Métodos: Son
de Noruega. funciones, que permiten
realizar acciones.
 Un equipo dirigi-do por el Normalmente
Dr. Nygaard
 Se dedicaba a desarrollar
sistemas infor-máticos
 Para realizar simulaciones
de sistemas físicos Atributos: almacenar Los Principales
datos internos al objeto Lenguaje de
(o clase). Programación