¿Qué es y en qué consiste la programación orientada a objetos?
Se
trata de un paradigma de programación.
Dos grandes grupos o categorías:
Leguajes
de programación orientados a procedimientos y orientados a objetos.
- Programación orientada a procedimientos: cobol, basic…
- Desventajas:
- Unidades de código muy
grandes en aplicaciones complejas.
- Código difícil de descifrar
en aplicaciones complejas.
- Código poco reutilizable.
- Error en una línea,
probable que el programa caiga.
- Difícil de depurar.
- Programación Orientada a Objetos: Php, C++, Java, Visual.Net…
-
En que consiste:
Trasladar la
naturaleza de los objetos de la vida real al código de programación.
- Cuál es la naturaleza de un objeto en la vida real:
Los objetos tienen un estado, un
comportamiento (qué puede hacer) y unas propiedades.
- El ejemplo del coche:
Cuál es el estado del coche:
Puede estar parado, circulando, aparcado…
Qué propiedades tiene: Tiene un
color, un peso, un tamaño…
Qué comportamiento: Puede
arrancar, frenar, acelerar, girar…
-
Ventajas:
- Programas divididos en partes,
módulos o clases. Modularización.
- Código muy reutilizable,
herencia.
- Si existe un fallo en una
línea de código el programa puede continuar.
- Encapsulamiento.
- Vocabulario o terminología:
-
Clase:
Modelo donde se redactan las características comunes a un grupo
de objetos.
En el caso del coche podrían ser el chasís y las ruedas, que pueden ser comunes
a varios coches.
Lo primero que tenemos que hacer es definir una clase que defina cuales son las
características comunes a nuestro objeto.
-
Objeto de clase, instancia y ejemplar son sinónimos:
Sería un objeto perteneciente a una clase.
Dos coches que comparten el mismo tipo de chasis y de ruedas.
- Modularización:
Lo normal es que una aplicación esté compuesta de varias clases.
Cada uno de los módulos funciona de forma independiente.
Permite la reutilización de código.
-
Encapsulación:
El funcionamiento interno de una clase concreta de un programa,
pertenece a ella misma, nada saben otras
clases de su funcionamiento.
Su funcionamiento está encapsulado, protegido de otras clases.
De todas formas todas la clases están conectadas para que funcionen como un
equipo, conjunto.
-
Métodos de acceso:
Conectan nuestras clases, para que funcionen como una unidad o
equipo. Pero sólo van a tener acceso a ciertas características de las clases.
- Para poder acceder a las propiedades y
comportamientos de un objeto (pseudocódigo), se utiliza la llamada nomenclatura
del punto.
Cosiste en crear un objeto llamado miObjeto.
Para acceder a las propiedades del objeto:
miObjeto.color=”rojo”
miObjeto.peso=1500;…
Para acceder al comportamiento:
miObjeto.arranca()
miObjeto.frena()
miObjeto.gira();…
# Sintaxis de Clase: Palabra reservada Class + Nombre primera letra en Mayuscula():
class Avion():
# Creamos Propiedades...
largo=100
ancho=15
alas=2
motores=2
ruedas=2
volar=False
# Creamos los comportamientos
por medio de métodos...
# Podemos crear un Método
o una Función. El Método es una función que pertenece a la clase.
# Una Función no pertenece
a ninguna clase.
# Palabra reservada def.
Nombre de función.
# Parámetro self que hace
referencia al objeto o instancia perteneciente a la clase... Equivalente al
$this en Php...
def despegar(self):
#pass # Palabra reservada para no
bloquear el programa inicialmente.
self.volar=True # Modificamos el comportamiento de volar.
def aterrizar(self):
self.volar=False
def estado(self):
if(self.volar==True):
return
"El avión está volando..."
else:
return
"El avión no vuela..."
# Salimos de la
clase...
# Creamos un Objeto, Instancia o Ejemplar de clase...
Avion01=Avion() # Instanciamos una clase. Creamos un objeto...
Sin el operador New como en Php...
# Acceder a las
propiedades del nuestro objeto...
print(f"Largo del
Avion: {Avion01.largo}")
print(f"Ancho del Avión: {Avion01.ancho}")
print(f"Número de Motores: {Avion01.motores}")
print(f"Volar es = {Avion01.volar}") # Comprobamos que la propiedad
volar el False.
Avion01.despegar() # Accedemos al Método
despegar...
print(f"Volar es
= {Avion01.volar}") # Comprobamos que la propiedad
volar es True
print(f"El estado
es: {Avion01.estado()}") # Comprobamos estado()
Avion01.aterrizar() # Accedemos al Método
aterrizar...
print(f"Volar es
= {Avion01.volar}") # Comprobamos la propiedad
volar...
print(f"El estado
es: {Avion01.estado()}") # Comprobamos el Método estado()
- ENCAPSULACIÓN: Proteger una
propiedad para que no pueda ser accesible desde fuera de la clase o ser
modificar desde fuera de esta.
Se realiza precediendo el nombre de la propiedad de dos guiones bajos.
Ejemplo desde el constructor:
self.__ruedas=4
No siempre es necesario encapsular los datos, pero puede darse el caso
de que sea necesario.
También podemos encapsular métodos.
# Sintaxis de
Clase: Palabra reservada Class + Nombre primera letra en Mayuscula():
class Avion():
# Creamos un método constructor...
# Da un estado inicial a
nuestros Objetos Instanciados a la clase...
def __init__(self):
# Creamos
Propiedades precedidas de self...
self.largo=100
self.ancho=15
self.__alas=2 # Encapsulamos la propiedad alas, para no ser accesible
desde fuera de la clase Avion...
self.motores=4
self.ruedas=6
self.__volar=False # Encapsulamos la propiedad alas, para no ser accesible
desde fuera de la clase Avion...
# Creamos un Método
Encapsulado para ser accesible sólo desde la clase...
def __TestAvion(self):
print("*
Test del Avion en curso...")
self.electronica=1
self.combustible=1
self.estructura=1
self.hidraulica=1
if(self.electronica==1
and self.combustible==1 and self.estructura==1 and self.hidraulica==1):
return
True
else:
return
False
# Creamos los comportamientos por
medio de métodos...
# Pasamos un parametro al
método, junto con self...
def despegar(self,despege,a,b,c,d):
self.__volar=despege
#print("***
",__TestAv)
if(self.__volar==True):
__TestAv=self.__TestAvion(a,b,c,d)
if(__TestAv==False):
return "Error en el Test del Avion..."
elif(__TestAv==True):
return "El avión está volando..."
else:
return "El avión no vuela..."
def propiedades(self):
print(f"-
Largo del Avion: {self.largo}")
print(f"-
Ancho del Avión: {self.ancho}")
print(f"-
Número de Motores: {self.motores}")
print(f"-
Número de alas: {self.__alas}")
print(f"-
Número de ruedas: {self.ruedas}")
# Salimos de la clase...
# Creamos un Objeto, Instancia o Ejemplar de clase...
Avion01=Avion()
print("** Primer Objeto Avion01")
'''
print(f"Largo del Avion: {Avion01.largo}")
print(f"Ancho del Avión: {Avion01.ancho}")
print(f"Número de Motores: {Avion01.motores}")
'''
print(f"- Estado
de Avion01: {Avion01.despegar(True,1,0,1,1)}")
print("* Propiedades de Avion01:")
Avion01.propiedades()
print("********
********")
# Segundo Objeto,
Instancia...
Avion02=Avion()
print("** Segundo Objeto Avion02")
'''
print(f"Largo del Avion: {Avion01.largo}")
print(f"Ancho del Avión: {Avion01.ancho}")
print(f"Número de Motores: {Avion01.motores}")
'''
print(f"- Estado
de Avion02: {Avion02.despegar(False,1,1,1,1)}")
print("* Propiedades de Avion02:")
Avion02.__alas=4 # Vemos como la propiedad alas
no es accesible desde fuera de la clase...
Avion02.propiedades()
No hay comentarios:
Publicar un comentario
Gracias por vuestros aportes.