Instituto Técnico Superior Comunitario

PROGRAMACION ORIENTADA A OBJETOS

Nombre y Matricula
Jefferson Alejandro Villanueva García
2017-0208
Facilitador
Daniel Parra
Sección
Contenido
Clases............................................................................................................. 3
Objetos........................................................................................................... 4
Atributos ........................................................................................................ 5
Métodos ......................................................................................................... 6
Instancia......................................................................................................... 6
Encapsulación: .............................................................................................. 7
La modularidad ............................................................................................. 7
Jerarquía ........................................................................................................ 8
La generalización .......................................................................................... 8
La herencia .................................................................................................... 8
Asociación ................................................................................................... 10
Polimorfismo: .............................................................................................. 10
Constructor .................................................................................................. 11
Destructor .................................................................................................... 11
Publico: ........................................................................................................ 11
Privado: ....................................................................................................... 12
Protegido ..................................................................................................... 12
Clases
Una clase es un conjunto de objetos que comparten una estructura y
comportamiento comunes.
 Clase representa una abstracción, la esencia que comparten los
objetos.
 Un objeto es un ejemplo de una clase.
 Un objeto no es una clase, y una clase no es un objeto (aunque puede
serlo, p.e. en Smalltalk).
 Las clases actúan como intermediarias entre una abstracción y los
clientes que pretenden utilizar la abstracción. De esta forma.
La clase muestra:
 Visión externa de comportamiento (interface), que enfatiza la
abstracción escondiendo su estructura y secretos de comportamiento.
 Visión interna (implementación), que abarca el código que se ofrece
en la interface de la clase.
Otras definiciones
Las clases son plantillas que
agrupan comportamiento y
estados de los futuros
objetos.
Los objetos son instancias de
una clase. Usando el símil
“variable – tipo” de la
programación estructurada,
se entiendo que un objeto es
una variable que tiene el
comportamiento y estados del
tipo.
Objetos
Objeto: Componente o código de software que contiene en sí mismo tanto
sus características (campos) como sus comportamientos (métodos); se
accede a través de su interfaz o signatura.
Se puede decir que un objeto es todo aquello que pueda ser identificable
dentro de una especificación de requerimientos o problema y tenga las
siguientes características:
 Tenga estados definibles (abierto, cerrado).
 Posea comportamientos asociados (puede correr, saltar, volar, etc.).
Éstos son denominados métodos.
 Son capaces de interactuar/comunicarse con otros objetos por medio
de sus métodos
 Una característica propia de este paradigma, es la transparencia entre
la implementación a nivel de código y la funcionalidad que provee
un método (no me interesa cómo lo haga, sólo que lo haga).
Atributos
Los atributos son las características individuales que diferencian un objeto
de otro y determinan su apariencia, estado u otras cualidades. Los
atributos se guardan en variables denominadas de instancia, y cada
objeto particular puede tener valores distintos para estas variables.
Las variables de instancia también denominados miembros dato, son
declaradas en la clase pero sus valores son fijados y cambiados en el
objeto.
Además de las variables de instancia hay variables de clase, las cuales se
aplican a la clase y a todas sus instancias. Por ejemplo, el número de ruedas
de un automóvil es el mismo cuatro, para todos los automóviles

También pueden incluir información acerca del estado de un objeto. En una

clase, los atributos estan definidos por variables. Cada objeto puede tener
valores distintos para sus variables y a éstas se les denomima variables de
instancia.
Una variable de instancia es un elemento de información que define un
atributo de un objeto en particular.
Métodos
Conjunto de instrucciones a las que se les asocia un nombre de modo que si
se desea ejecutarlas, sólo basta o referenciarlas a través de dicho nombre en
vez de tener que escribirlas.
Dentro de estas instrucciones es posible acceder con total libertad a la
información almacenada en los campos, pertenecientes a la clase dentro de
la que el método se ha definido. Por lo que los métodos permiten manipular
los datos almacenados en los objetos.

Instancia
Yo entiendo que la instancia de un objeto es cuando creamos un nuevo
objeto y le reservamos un espacio en la memoria:
Object obj = new Object ();
Se llama instancia a todo objeto que derive de algún otro. De esta forma,
todos los objetos son instancias de algún otro, menos la clase Object que es
la madre de todas.
Encapsulación:
Define el comportamiento de una clase u objeto que tiene dentro de él todo
tipo de métodos y datos pero que solo es accesible mediante el paso de
mensajes. Y los datos a través de los métodos del objeto/clase.

La modularidad
Es, en programación modular y más específicamente en programación
orientada a objetos, la propiedad que permite subdividir una aplicación en
partes más pequeñas (llamadas módulos), cada una de las cuales debe ser
tan independiente como sea posible de la aplicación en sí y de las restantes
partes.
Estos módulos que se puedan compilar por separado, pero que tienen
conexiones con otros módulos. Al igual que la encapsulación, los lenguajes
soportan la Modularidad de diversas formas. La modularidad debe seguir
los conceptos de acoplamiento y cohesión.
Jerarquía
Si estás creando un gran conjunto de clases, tendrá sentido que éstas hereen
de la jerarquía de clases y conformen una jerarquía por sí
mismas. Organizar clases de esta manera implica invertir un tiempo
considerable de planeación, pero las ventajas son las siguientes:
La funcionalidad que es común a múltiples clases se puede colocar en
superclases, lo que le permite ser utilizada repetidamente en todas las
clases inferiores de la jerarquía.
Los cambios en la superclase se reflejan automáticamente en todas sus
subclases, las subclases de éstas y así sucesivamente. No hay necesidad de
cambiar o recompilar cualquiera de las clases inferiores; reciben toda la
información a través de la herencia.

La generalización
Es la propiedad que permite compartir información entre dos entidades
evitando la redundancia.
En el comportamiento de objetos existen con frecuencia propiedades que
son comunes en diferentes objetos y esta propiedad se denomina
generalización.

La herencia
Permite definir nuevas clases a partir de otras clases ya existentes, de modo
que presentan las mismas características y comportamiento de éstas, así
como otras adicionales.
Cuando se crea un objeto nuevo, el lenguaje registra cada variable definida
para el objeto y cada variable definida para cada superclase del objeto. De
este modo, todo lo que contienen en las clases se combina para formar una
estructura descriptiva del objeto en uso y cada objeto aporta la información
apropiada para su situación.
Los métodos trabajan de manera parecida: los objetos nuevos tienen acceso
a todos los nombres de los métodos de su clase y superclase. Esto
determina de manera dinámica cuando se usa un método en un programa en
ejecución. Si se hace un llamado a un método en un objeto en particular, el
intérprete del lenguaje primero revisará la clase del objeto para este
método. Si no lo encuentra, lo busca en la superclase y así sucesivamente
hasta encontrar la definición del método.
Las cosas se complican cuando una subclase define un método que tiene el
mismo nombre, tipo de valor de retorno y argumentos que otro método
definido en una superclase. En este caso, la definición del método que se
localiza primero (comenzando por el fondo de la jerarquía y desplazándose
hacia arriba) es la que se ha empleado. En consecuencia, puede crear un
método en una clase que evite
que se use un método de una
superclase. Para hacerlo, crea
un método con el mismo
nombre, tipo de valor de
retorno y argumentos como el
método de la superclase. A
este proceso se le denomina
sobre posición.
Asociación
La asociación se podría definir como el momento en que dos objetos se
unen para trabajar juntos y así, alcanzar una meta.
Un punto a tomar muy en cuenta es que ambos objetos son independientes
entre sí, veremos un poco más adelante qué implicación tiene esto. Para
validar la asociación, la frase “Usa un”, debe tener sentido:
 El ingeniero usa una computadora
 El cliente usa tarjeta de crédito.

Polimorfismo:
Los objetos responden a los mensajes que se les envían. Un mismo mensaje
puede ser interpretado o dar paso a distintas acciones según que objeto es el
destinatario.
Con este sistema el emisor se desentiende de los detalles de la ejecución
(aunque el programador ha de saber en todo momento cuales son las
consecuencias de ese mensaje).
Constructor

Es una subrutina cuya misión es inicializar un objeto de una clase. En el

constructor se asignan los valores iniciales del nuevo objeto.
Se utiliza para crear tablas de clases virtuales y poder así desarrollar el
polimorfismo, una de las herramientas de la programación orientada a
objetos. Al utilizar un constructor, el compilador determina cuál de los
objetos va a responder al mensaje (virtual) que hemos creado. Tiene un tipo
de acceso, un nombre y un paréntesis.

Destructor

En programación orientada a objetos es una función miembro especial

llamadas automáticamente en la ejecución del programa, y por tanto
no tienen por qué ser llamadas explícitamente por el programador. Sus
principales cometidos son:
 Libera los recursos computacionales que el objeto de dicha clase
haya adquirido en su tiempo de ejecución al expirar éste.
 Quitar los vínculos que pudiesen tener otros recursos u objetos con
éste.
 Los destructores son invocados automáticamente al alcanzar el flujo
del programa el fin del ámbito en el que está declarado el objeto.

Publico:

Una variable/función pública puede ser accedida desde fuera de la clase. Es

decir, puedo acceder desde la instancia de la clase y no sólo desde el código
interno de la clase. Ejemplo de funciones públicas son los métodos de una
clase. También es posible crear variables públicas, para que puedan ser
manejadas desde la instancia, pero no es algo común o recomendable, entre
otras cosas porque deja un hueco de seguridad en la clase, acabando con la
idea de la “encapsulación”. Para declarar una variable/función como
pública, se le antepone la palabra clave “publicó”.
Privado:
Al contrario que las públicas, las variables/funciones privadas sólo pueden
ser accedidas desde dentro de la misma clase. Todo intento de llamarlas
desde la una instancia de la misma es en vano. Mantener
variables/funciones privadas permiten tener un mayor control sobre la
clase, sobre el modo como procesa sus métodos, como maneja sus
variables, etc. Para declarar una variable/función como privada, se le
antepone la palabra clave “prívate”.

Protegido

Existe un tipo intermedio de ámbito, llamado “protegido”. Es un punto

medio entre público y privado, porque -como ocurre con las privadas- no se
puede acceder a ella desde una instancia de la clase, pero -como ocurre con
las públicas- puede ser accedido desde las subclases de ésta, no importa si
se encuentran o no en el mismo paquete. Básicamente significa que, si una
clase hereda de otra, tendrá acceso a las variables/funciones protegidas de
la súper-clase, de lo contrario, no podrá acceder a ellas. Para declarar una
variable como protegida, se le antepone la palabra clave “protector”.