POO
POO
surgen entre las décadas de los 60/70 y
son las siglas de Programación Orientada a Objetos que viene del Inglés
OOP (Object Oriented Programming). Es un paradigma informático que en su
momento revolucionó la forma de programar, anteriormente la programación estaba
orientada a procedimientos (Fortran, Cobol, Basic, etc), esto generaba una
serie de problemas:
·
El código era muy largo
·
En caso de error era muy complejo de
solucionarlo por otro programador, porque era fácil acabar creando código
espagueti (instrucciones como go to o go sub hacían que el programa saltara
constante mente de un lado a otro).
·
Si existía un error el programa se caía.
·
Era muy complicado reutilizar un programa para
otro que fuera parecido.
Para resolver
todos estos problemas se generó POO. El programa que creamos se subdivide en
pequeños programas u objetos (módulos o clases), independientes que al final se
unen formando un todo (modularización). Cada
objeto va a tener una serie de
características (un estado, unas
propiedades o atributos y un
comportamiento).
Esto nos
facilita mucho las cosas, ¿para qué sirve dividir el programa en objetos?:
·
Si un objeto se cae el resto del programa puede
seguir funcionando, debido a la modularización del programa.
·
Es más fácil detectar en que parte del programa
está fallando ya que iremos directamente al objeto que falla. Tratamiento de
excepciones.
·
Podemos reutilizar cada uno de nuestros objetos
en un nuevo programa (herencia).
·
Encapsulamiento los objetos son completamente
independientes, se comunican entre sí en un punto determinado pero no tiene por
qué depender del resto.
Un objeto tendrá una serie de características:
Un estado:
Como se encuentra en este justo momento (Activo, inactivo; encendido, pagado;
incrementar, decrecer, estático, dinámico…)
Unas propiedades
o atributos: Características del objeto (Color, peso, altura…)
Un comportamiento
o método: ¿Qué puede hacer? (Sumar, restar, dividir, encender, apagar).
Clase:
Modelo donde se redactan las características comunes de un grupo de objetos.
Arrancando con esa base se pueden construir diferentes objetos.
o
Ejm. El tronco de un árbol: todos los
arboles tienen un tronco como base.
§ A
partir de esto existen diferentes objetos: Naranjo, olivo, abedul, pino….
Objeto:
Ejemplar perteneciente a una clase y pose una serie de propiedades y comportamientos.
o
Propiedades (atributos): valor, color,
posición…
o
Comportamientos ¿Qué es capaz de
hacer? : sumar, restar, multiplicar, cambiar de color, modificar su posición en
el espacio, encender, apagar….
Nosotros podremos acceder a las propiedades y comportamiento desde
(pseudocódigo).
Ø Propiedades
o atributos: Son las Variables o constantes que tiene una clase. Para acceder a
las propiedades y modificarlas utilizamos la nomenclatura del punto ( nombre_objeto . propiedad = Valor)
o
Arbol.color=”amarrilo”;
o
Arbol.Altura=2000;
o
Arbol.ancho=50;
Ø Comportamiento
o método: Para acceder a los comportamientos y modificarlas utilizamos la nomenclatura del punto ( nombre_objeto .
método () ).
o
Arbol.Flexividad();
o
Arbol.Crecimineto();
o
Arbol.Enraizamiento();
Ejemplar de clase. Instancia de clase.
Ejemplarizar una clase. Instanciar una clase: Hacer una llamada a una clase
para poderla utilizar.
Ejemplo.
1º.
Crearemos una clase llamada árbol.
package poo_arbol;
public class arbol {
// ATRIBUTOS
int alto,ancho;
String copa,colorHoja;
//le daremos
valor a cada una de las propiedades
COMPORTAMIENTOS O MÉTODOS
public arbol() {
alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde";
}
}
2º. Ahora utilizaremos la
Clase árbol para construir el Naranjo.
public class Arbol_Naranjo {
public static void main(String[] args) {
/* Instanciar
una clase. Ejemplar de clase:
* realizamos una llamada al
arbol que es la matriz con una
serie de valores
* prederterminados ya por
nostros y que ahora podemos utilizar o modificar.
*/
arbol Naranjo = new arbol();
System.out.println
("UN NARANJO TIENE: \n\n"
+ "De color de hoja: " + Naranjo.colorHoja + "\n"
+ "con una
altura de: " + Naranjo.alto + "\n"
+ "su
tronco tiene una circunferencia de:
" + Naranjo.ancho + "\n"
+ "Su
compa es :
" + Naranjo.copa + "\n"
);
}
}
Modularización:
Dividir un programa en módulos o ficheros (lclases). Cuando construimos un
programa necesitaremos como mínimo dos clases. Siempre existirá una clase
principal donde estará el método main que es en la que se ejecuta el programa. En el
instanciaremos otras clases.
Encapsulamiento/encapsulación:
Es proteger las propiedades o atributos en nuestro caso sería la clase árbol (alto,ancho,copa,colorHoja).
Para ello pondremos el modificador de acceso pribate delante
de las variables. Así evitaremos que las propiedades o atributos puedan ser
modificados en otra clase.
Ejm.
package poo_arbol;
public class arbol {
// ATRIBUTOS
LOS ENCAPSULAMOS CON PRIVATE
private int alto,ancho;
private String copa,colorHoja;
//METODO CONSTRUCTOR
en el que le damos valor
a nuestras variables
public arbol() { alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde"; }
}
Métodos: Es la forma que tiene de
comunicarse las clases entre sí, los
conectores.
o
Método
Gettes o captadores: Devuelve o capta el valor de
una propiedad sin modificarlo.
§ Public int/String… variable
(){return + código ;}
o
Método
Stters o definidores: Define o establece el valor de
una propiedad.
§ Public
void nombre_metodo(){codigo}
La palabra void
indica que el método no devuelve ningún valor.
Ejm.
package poo_arbol;
public class arbol {
// ATRIBUTOS
LOS ENCAPSULAMOS CON PRIVATE
private int alto,ancho;
private String copa,colorHoja;
private int oscilacion,absorcion_agua;
private boolean es_de_secano,Es_de_Humedal;
//CONSTRUCTOR
EN EL QUE LE DAMOS VALOR A NUESTRAS VARIABLES
public arbol() { alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde"; }
// METODO GETTER: permite mostrar
public int r_alto() {return alto;} // método getter
public int r_ancho() {return ancho;} // método getter
public String r_copa() {return copa;} // método
getter
public String r_colorHoja() {return colorHoja;} // metodo getter
// METODO
SETTER: modifica valores de las variables
public void setter_oscilacion() {oscilacion=20;}
public void setter_absorcion() {absorcion_agua=50;}
public void setter_es_de_secano() {es_de_secano=true;}
public void setter_Es_de_Humedal() {Es_de_Humedal=false;}
}
package poo_arbol;
public class Arbol_Naranjo {
public static void main(String[] args) {
/* instanciar
una clase. ejemplar de clase:
* realizamos una llamada al
arbol que es la matriz con una
serie de valores
* prederterminados ya por
nostros y que ahora podemos utilizar o modificar.
*/
arbol Naranjo = new arbol();
System.out.println
("UN NARANJO TIENE: \n\n"
+ "De
color de hoja:
" + Naranjo.r_colorHoja() + "\n"
+ "con una
altura de: " + Naranjo.r_alto() + "\n"
+ "su
tronco tiene una circunferencia de:
" + Naranjo.r_ancho () + "\n"
+ "Su
compa es :
" + Naranjo.r_copa () +
"\n"
);
}
Principio de sustitución: Se puede utilizar un objeto de una sub clase siempre que el programa espere un objeto de la Superclase. Por lo que un objeto se puede comportar de diferente manera dependiendo del contexto. Podremos utilizarlo siempre que podamos decir ES UN. En el siguiente caso podemos decir cerdo es carne y pollo es carne.
Carne [] Cerdo=new Carne[5];
Carne [] Pollo =new Carne[6];
Carne [] ArticulosCarne=new Carne[11];
for (int x=0; x<5; x++) {ArticulosCarne[x]= Cerdo[x];}
for (int y=5,x=0;y<11 && x<6;y++,x++){ArticulosCarne[y]=Pollo[x];}
No hay comentarios:
Publicar un comentario