HECHO POR “”HUITZIZIHUITL GARCIA VITELA”“ INSTITUTO TECNOLOGICO DE SAN PEDRO COAHUILA TEC 100?
La herencia Como bien se sabe la herencia no se reparte: se descuartiza. Bromas aparte, la herencia constituye una de las herramientas mas poderosas de culto OO. Si una clase hereda de la otra, lo que hereda son todos sus atributos y metodos. Ademas de heredarlos puede sobreescribirlos, tanto los constructores-destructores como los metodos convencionales. Veremos un ejemplo claro que resume lo que se puede hacer y los efectos de la herencia
PROGRAMA EN MODO CONSOLA EXPLICADO CADA UNA DE SUS PARTES
- include <iostream.h> //Libreria para la entrada/salida de datos
main() //Comienza la funcion principal {
class vehiculo //Declaramos la superclase vehiculo
{
protected: //Le ponemos tipo protegido a los datos para que se pasen a la variante
float peso; //Variable tipo decimal que guardara el peso
int ruedas; //Variable tipo intero que guardara el nº de ruedas
public: //Le ponemos tipo publico a los constructores para poder utilizarlos en todo el programa
void iniciar(float p,int r) //Este constructor se dedica a enlazar las variables del
{ //main principal con las de las clases por eso se pasan por parametros
peso = p; //La variable peso sera igual a la variable p
ruedas = r; //La variable ruedas sera igual a la variable r
}; //Fin del constructor iniciar
float ob_peso(void) //Constructor de tipo decimal que muestra el peso
{ return peso; }; //Devuelve el peso con return
int ob_ruedas(void) //Constructor de tipo entero que muestra el nº de ruedas
{ return ruedas; }; //Devuelve las ruedas con return
}; //Fin de la declaracion de la superclase vehiculo
class motocicleta:public vehiculo //Declaramos la clase variante llamada motocicleta
{ //Hacemos que se pase todo lo protegido y publico a esta variante con :public vehiculo
private: //Aunque por defecto si no se pone el tipo es private, pero lo ponemos
int pasajeros; //Variable de tipo entero que guardara el nº de pasajeros
int combustible; //Variable de tipo entero que guardara el combustible
char tipo; //Variable de tipo caracter que guardara una tecla
public: //Le ponemos tipo publico a los constructores para poder utilizarlos en todo el programa
void iniciar(int pj,int com,int r,float p) //Este constructor se dedica a enlazar las
{ //variables del main principal con las de las clases por eso se pasan por parametros
pasajeros = pj; //La variable pasajeros sera igual a pj
combustible = com; //La variable combustible sera igual a com
ruedas = r; //La variable ruedas sera igual a r
peso = p; //La variable peso sera igual a p
}; //Fin del constructor iniciar
int ob_pasajeros(void) //Constructor tipo entero para obtener el nº de pasajeros
{ cout << endl << “Que tipo de moto es ?”; //Datos de salida
cout << endl << “Grande: Pulse G - Chica: Pulse C\\n”; //Datos de salida
cin >> tipo; //Dato de entrada hacia la variable tipo char llamada tipo
if((tipo == ‘g’) || (tipo == ‘G’)) //Si hemos pulsado g o G
{ pasajeros=pasajeros+1; } //pasajeros se incrementara 1
if((tipo == ‘c’) || (tipo == ‘C’)) //Si hemos pulsado c o C
{ pasajeros=pasajeros-1; } //pasajeros se decrementara 1
return pasajeros; //Devuelve con return el valor de la variable pasajeros
}; //Fin del constructor ob_pasajeros
int ob_combustible(void) //Constructor tipo entero para obtener el nº de combustible
{ //Se utiliza el mismo valor anterior con la variable char tipo
if((tipo == ‘g’) || (tipo == ‘G’)) //Si habiamos pulsado g o G
{ combustible=combustible+20; } //El valor de combustible sera 20 mas
if((tipo == ‘c’) || (tipo == ‘C’)) //Si habiamos pulsado c o C
{ pasajeros=20; } //El valor de combustible sera 20
return combustible; //Devuelve con return el valor de combustible
}; //Fin del constructor ob_combustible
}; //Fin de la declaracion de la clase variante motocicleta
int r=2,pj=2,com=20; //Declaramos variables enteras:
//r sera el numero de ruedas
//pj sera el numero de pasajeros
//com sera el numero de combustible
float p=96.5; //Declaramos variables decimales:
//p sera el peso
motocicleta moto; //Declaramos una variable tipo sub-clase moticicleta llamada moto
moto.iniciar(pj,com,r,p); //Llamamos al constructor iniciar desde moto, le pasamos los parametros
pj=moto.ob_pasajeros(); //Asignamos el valor del constructor ob_pasajeros a pj
cout << endl << “Caracteristicas de un ciclomotor”; //Datos de salida
cout << endl << “Peso: “ << moto.ob_peso() << “kg”; //Datos de salida, llamamos a ob_peso
cout << endl << “Ruedas: “ << moto.ob_ruedas(); //Datos de salida, llamamos a ob_ruedas
cout << endl << “Pasajeros: “ << pj; //Datos de salida, ponemos a mostrar pj
cout << endl << “Combustible: “ << moto.ob_combustible() << “litros”; //Datos de salida, llamamos
cout << endl; //a ob_combustible
cin.get(); //Limpia el buffer
cin.get(); //Espera a que pulses una tecla
} //Fin de la funcion principal
POO EN JAVA **GARCIA BAÑUELOS YEUDIEL ITZ SALUDOS A MI NOVIA LIZBET ITM TE EXTRAÑO**
Java está completamente orientado a objetos. Un programa consta de una o más clases, éstas pueden organizarse en paquetes. Las clases de Java definen objetos de software encerrando los miembros de los datos (campos) y a los miembros de función(métodos). Los miembros pueden designarse como privados, protegidos de paquete o públicos, lo que proporciona una manera conveniente de definir la interfaz pública y el dominio privado de un objeto.
El mecanismo de Java para la herencia es la extensión de clase, que permite las relaciones de tipo y el reuso de código. Sólo se permite la herencia simple. La sobreescritura dinámica de métodos soporta polimorfismo y permite la construcción de objetos intercambiables que se adecuan a una interfaz uniforme. La superclase abstracta de Java le ayuda a planear interfaces uniformes para un conjunto de objetos compatibles de conexión, además de proporcionar código común para éstos.