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

  1. 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.