herencia lenguaje de programacion

76
Herencia La herencia es uno de los conceptos más importantes en la programación orientada a objetos junto con la encapsulación y polimorfismo. Básicamente permite reutilizar el código porque una sub-clase (clase hija o derivada) puede usar fácilmente las propiedades y métodos definidos en la super clase (clase padre). El objetivo de esta práctica es exponer el concepto de herencia en Java. Se mostrará cómo crear una clase Java extendiendo otra clase. Se verá tambien que la clase Object es la madre de todas las clases. Se aprenderá a sobreescrobir (override) un método de la clase padre. Se verá cómo hacer un type casting entre instancias de objetos que están relacionados a través de la herencia. Finalmente se verá el uso de las clases y métodos final. Recursos Inheritance de Java Tutorial Overriding vs Hiding artículo de javaranch.com Ejercicios Ejercicio 1: Compilar y ejecitar un programa Java que usa clases que están relacionadas a través de la herencia Ejercicio 2: Cadena de llamada a constructor y la palabra reservada super Ejercicio 3: Overriding de métodos Ejercicio 4: Type casting Ejercicio 5: Clases y métodos final Ejercicio 6: Construcción de una aplicación Tarea Ejercicio 1: Compilar y ejecitar un programa Java que usa clases que están relacionadas a través de la herencia En este ejercicio se va a escribir un programa en el que varias clases, que están relacionadas mediante la herencia se crean y usan. Primero se crea una clase Person. Después se crean subclases de la clase Person, clase Student y clase Teacher. También se crea una subclase de la clase Student, que se llama clase InternationalStudent class. 1. Compilar y ejecutar un programa Java que usa clases relacionadas 2. Ver la jerarquía de la herencia con el IDE (1.1) Compilar y ejecutar un programa Java que usa clases relacionadas

Upload: hiden-jaome-machaca-huancollo

Post on 24-Jul-2015

144 views

Category:

Education


1 download

TRANSCRIPT

Page 1: Herencia lenguaje de programacion

Herencia La herencia es uno de los conceptos más importantes en la programación orientada a objetos junto con la encapsulación y polimorfismo. Básicamente permite reutilizar el código porque una sub-clase (clase hija o derivada) puede usar fácilmente las propiedades y métodos definidos en la super clase (clase padre).

El objetivo de esta práctica es exponer el concepto de herencia en Java. Se mostrará cómo crear una clase Java extendiendo otra clase. Se verá tambien que la clase Object es la madre de todas las clases. Se aprenderá a sobreescrobir (override) un método de la clase padre. Se verá cómo hacer un type casting entre instancias de objetos que están relacionados a través de la herencia. Finalmente se verá el uso de las clases y métodos final.

Recursos

Inheritance de Java Tutorial Overriding vs Hiding artículo de javaranch.com

Ejercicios

Ejercicio 1: Compilar y ejecitar un programa Java que usa clases que están relacionadas a través de la herencia

Ejercicio 2: Cadena de llamada a constructor y la palabra reservada super Ejercicio 3: Overriding de métodos Ejercicio 4: Type casting Ejercicio 5: Clases y métodos final Ejercicio 6: Construcción de una aplicación Tarea

Ejercicio 1: Compilar y ejecitar un programa Java que usa clases que están relacionadas a través de la herencia

En este ejercicio se va a escribir un programa en el que varias clases, que están relacionadas mediante la herencia se crean y usan.  Primero se crea una clase Person.  Después se crean subclases de la clase Person, clase Student y clase Teacher. También se crea una subclase de la clase Student, que se llama clase InternationalStudent class.

1. Compilar y ejecutar un programa Java que usa clases relacionadas 2. Ver la jerarquía de la herencia con el IDE

(1.1) Compilar y ejecutar un programa Java que usa clases relacionadas

1. Crear un nuevo proyecto NetBeans

Seleccionar File->New Project (Ctrl+Shift+N). El diálogo New Project aparece.

En la sección Choose Project seleccionar Java en la sección Categories y Java Application en la sección Projects.

Pulsar en Next.

Page 2: Herencia lenguaje de programacion

En la sección Name and Location, del campo Project Name, escribir MyPeopleExample. (Figura-1.10 )

Click Finish.

Page 3: Herencia lenguaje de programacion

Figura-1.10: Create a new project

Observar que aparece el nodo del proyecto MyPeopleExample se crea en la sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor del IDE.

Page 4: Herencia lenguaje de programacion

2. Escribir Person.java.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Person.

Page 5: Herencia lenguaje de programacion

o En el campo Package, escribir mypeopleexample o seleccionar mypeopleexample a partir del menú desplegable . (Figura-1.11 )

Click en Finish.

Figura-1.11: Creación de Person.java

Observar que se genera y muestra en la ventana del editor Person.java. Modificar Person.java como se muestra en Código-1.12.  Notar que la clase

Person tiene dos campos, name y address, y los métodos getter y setter para ellos.

package mypeopleexample;

public class Person {        private String name;    private String address;

    public String getName() {        return name;    }

Page 6: Herencia lenguaje de programacion

    public void setName(String name) {        this.name = name;    }

    public String getAddress() {        return address;    }

    public void setAddress(String address) {        this.address = address;    }    }

Código-1.12: Person.java

3. Escribir Student.java. Notar que la clase Student es una subclase de la clase Person.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Student. En el campo Package, escribir mypeopleexample o seleccionar

mypeopleexample a partir del menú desplegable . (Figura-1.11 ) Click en Finish.

Page 7: Herencia lenguaje de programacion

Observar que se genera y muestra en la ventana del editor Student.java. Modificar Student.java como se muestra en Código-1.13.  Notar que la clase

Student tiene dos campos, school y grade, y métodos getter y setter para ellos.

package mypeopleexample;

public class Student extends Person {        private String school;    private double grade;

    public String getSchool() {        return school;    }

    public void setSchool(String school) {        this.school = school;    }

    public double getGrade() {        return grade;    }

Page 8: Herencia lenguaje de programacion

    public void setGrade(double grade) {        this.grade = grade;    }}

Código-1.13: Student.java

4. Escribir InternationalStudent.java. Notar que la clase InternationalStudent es una subclase de la clase Student.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir InternationalStudent. En el campo Package, escribir mypeopleexample o seleccionar

mypeopleexample a partir del menú desplegable . Click en Finish.

Observar que se genera y muestra en la ventana del editor InternationalStudent.java.

Page 9: Herencia lenguaje de programacion

Modificar InternationalStudent.java como se muestra en Código-1.14.  Notar que la clase InternationalStudent tiene un campo, country, y métodos getter y setter.

package mypeopleexample;

public class InternationalStudent extends Student {        private String country;

    public String getCountry() {        return country;    }

    public void setCountry(String country) {        this.country = country;    }    }

Código-1.14: InternationalStudent.java

5. Escribir Teacher.java.  Notar que la clase Teacher es una subclase de la clase Person.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Teacher. En el campo Package, escribir mypeopleexample o seleccionar

mypeopleexample a partir del menú desplegable . Click Finish.

Page 10: Herencia lenguaje de programacion

Observar que se genera y muestra en la ventana del editor Teacher.java. Modificar Teacher.java como se muestra en Código-1.16. Notar que la clase

Teacher tiene un campo, subject, y métodos getter y setter para su gestión.

package mypeopleexample;

public class Teacher extends Person {        private String subject;

    public String getSubject() {        return subject;    }

    public void setSubject(String subject) {        this.subject = subject;    }}

Código-1.16: Teacher.java

6. Modificar Main.java.

Page 11: Herencia lenguaje de programacion

Modificar the Main.java como se muestra en Código-1.17. El cambio es para crear objetos de las clases Person, Student, InternationalStudent, y Teacher.

package mypeopleexample;

public class Main {        public static void main(String[] args) {                // Create object instances and invoke methods.        // Note that you can use methods defined in a parent        // class for object instances of the child class.                Person person1 = new Person();        person1.setName("Tom Jones");                Student student1 = new Student();        student1.setName("CCR");        student1.setSchool("Lexington High");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.setName("Bill Clinton");        internationalStudent1.setSchool("Lexington High");        internationalStudent1.setCountry("Korea");                Teacher teacher1 = new Teacher();        teacher1.setName("Beatles");        teacher1.setSubject("History");                // Display name of object instances using the getName() method        // defined in the Person class.        System.out.println("Displaying names of all object instances...");        System.out.println("  person1.getName() = " + person1.getName());        System.out.println("  student1.getName() = " + student1.getName());        System.out.println("  internationalStudent1.getName() = " +                internationalStudent1.getName());        System.out.println("  teacher1.getName() = " + teacher1.getName());            }}

Código-1.17: Main.java

7. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-1.18 )

Displaying names of all object instances...  person1.getName() = Tom Jones  student1.getName() = CCR  internationalStudent1.getName() = Bill Clinton  teacher1.getName() = Beatles

Figura-1.18: Resultado de la ejecución de la aplicación      

Page 12: Herencia lenguaje de programacion

                                                                                                                        Volver al inicio del ejercicio

(1.3) Ver la jerarquía de la herencia a través del método getSuperclass() de la clase Class

En este paso, se va a mostrar la jerarquía de clases a través del uso de un método de la API - getSuperclass() de una clase Class class - en el programa.

1. Modificar Main.java como se muestra en Código-1.30.  El fragmento de código a añadir está en azul.

package mypeopleexample;

public class Main {        public static void main(String[] args) {                // Create object instances and invoke methods.        // Note that you can use methods defined in a parent        // class for object instances of the child class.                Person person1 = new Person();        person1.setName("Tom Jones");                Student student1 = new Student();        student1.setName("CCR");        student1.setSchool("Lexington High");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.setName("Bill Clinton");        internationalStudent1.setSchool("Lexington High");        internationalStudent1.setCountry("Korea");                Teacher teacher1 = new Teacher();        teacher1.setName("Beatles");        teacher1.setSubject("History");                // Display name of object instances using the getName() method        // defined in the Person class.        System.out.println("Displaying names of all object instances...");        System.out.println("  person1.getName() = " + person1.getName());        System.out.println("  student1.getName() = " + student1.getName());        System.out.println("  internationalStudent1.getName() = " +                internationalStudent1.getName());        System.out.println("  teacher1.getName() = " + teacher1.getName());                // Display the class hierarchy of the InternationalStudent        // class through getSuperclass() method of Class class.        Class class1 = internationalStudent1.getClass();                System.out.println("Displaying class hierarchy of InternationalStudent Class...");        while (class1.getSuperclass() != null){             String child = class1.getName();            String parent = class1.getSuperclass().getName();            System.out.println("  " + child + " class is a child class of " + parent);            class1 = class1.getSuperclass();           }    }

Page 13: Herencia lenguaje de programacion

}

Código-1.30: Main.java modificado

2. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-1.31 )

Displaying names of all object instances...  person1.getName() = Tom Jones  student1.getName() = CCR  internationalStudent1.getName() = Bill Clinton  teacher1.getName() = BeatlesDisplaying class hierarchy of InternationalStudent Class...  mypeopleexample.InternationalStudent class is a child class of mypeopleexample.Student  mypeopleexample.Student class is a child class of mypeopleexample.Person  mypeopleexample.Person class is a child class of java.lang.Object

Figura-1.31: Resultado de la ejecución de la aplicación

                                                                                                                        Volver al inicio del ejercicio

Resumen

En este ejercicio se ha visto la creación de objetos que están relacionados a través de la herencia.                                                                                                                                       Volver al inicio

Ejercicio 2: Encadenamiento de llamadas a Constructor

En este ejercicio, se experimenta con el concepto de la llamada encadenada de constructor y cómo usar el método super() y la referencia super.

1. Cadena de llamada a Constructor 2. método super() 3. referencia super

(2.1)Cadena de llamada a Constructor

Se va a usar el proyecto MyPeopleExample para los cambios que se van a realizar esta sección o se puede crear otro proyecto nuevo, por ejemplo, MyPeopleExampleConstructor, mediante "copia" del proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample project y seleccionar Copy Project. Es esta parte se asume que se ha creado el proyecto nuevo.

1. Modificar Person.java como se muestra en Código-2.10.  El cambio consiste en añadir una sentencia de impresión dentro del constructor. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Person {

Page 14: Herencia lenguaje de programacion

        public Person() {        System.out.println("Person: constructor is called");    }        private String name;    private String address;        public String getName() {        return name;    }        public void setName(String name) {        this.name = name;    }        public String getAddress() {        return address;    }        public void setAddress(String address) {        this.address = address;    }    }

Código-2.10: Person.java

2. Modificar Student.java como se muestra en Código-2.11. El cambio consiste en añadir una sentencia de impresión dentro del constructor. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Student extends Person {        public Student() {        System.out.println("Student: constructor is called");    }        private String school;    private double grade;        public String getSchool() {        return school;    }        public void setSchool(String school) {        this.school = school;    }        public double getGrade() {        return grade;    }        public void setGrade(double grade) {        this.grade = grade;    }}

Page 15: Herencia lenguaje de programacion

Código-2.11: Student.java

3. Modificar InternationalStudent.java como se muestra en Código-2.12. El cambio consiste en añadir una sentencia de impresión dentro del constructor. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class InternationalStudent extends Student {        public InternationalStudent() {        System.out.println("InternationalStudent: constructor is called");    }            private String country;

    public String getCountry() {        return country;    }

    public void setCountry(String country) {        this.country = country;    }    }

Código-2.12: InternationalStudent.java

4. Modificar Teacher.java como se muestra en Código-2.13. El cambio consiste en añadir una sentencia de impresión dentro del constructor. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Teacher extends Person {        public Teacher() {        System.out.println("Teacher: constructor is called");    }        private String subject;        public String getSubject() {        return subject;    }        public void setSubject(String subject) {        this.subject = subject;    }}

Código-2.13: Teacher.java

5. Modificar Main.java como se muestra en Código-2.14. El cambio consiste en añadir una sentencia de impresión dentro del constructor. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Main {        public static void main(String[] args) {

Page 16: Herencia lenguaje de programacion

                // Create an object instance of         // InternationalStudent class.        System.out.println("---- About to create an object instance of InternationalStudent class...");        InternationalStudent internationalStudent1 =                new InternationalStudent();                // Create an object instance of         // Teacher class.         System.out.println("---- About to create an object instance of Teacher class...");        Teacher teacher1 = new Teacher();            }}

Código-2.14: Main.java modificado

6. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExampleConstructor y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-2.15)

---- About to create an object instance of InternationalStudent class...Person: constructor is calledStudent: constructor is calledInternationalStudent: constructor is called---- About to create an object instance of Teacher class...Person: constructor is calledTeacher: constructor is called

Figura-2.15: Resultado

                                                                                                                        Volver al inicio del ejercicio

(2.2) método super()

Se puede usar el proyecto MyPeopleExample para el cambio que se va a realizar en este paso o se puede crear un proyecto nuevo, por ejemplo MyPeopleExampleConstructorSuper, mediante "copia" del proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample project y seleccionar Copy Project. Esta sección asume que se ha creado el proyecto nuevo.

1. Modificar Person.java como se muestra en Código-2.16.  El cambio consiste en añadir otro constructor que se puede llamar desde una subclase. El fragmento de código que se require añadir se muestra en azul..

package mypeopleexample;

public class Person {        public Person() {        System.out.println("Person: constructor is called");    }

    public Person(String name) {

Page 17: Herencia lenguaje de programacion

        this.name = name;        System.out.println("Person: constructor 2 is called");    }        private String name;    private String address;        public String getName() {        return name;    }        public void setName(String name) {        this.name = name;    }        public String getAddress() {        return address;    }        public void setAddress(String address) {        this.address = address;    }    }

Código-2.16: Person.java

2. Modificar Student.java como se muestra en Código-2.17.  El cambio es la llamada del método constructor de la super clase usando el método super().  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Student extends Person {        public Student() {        System.out.println("Student: constructor is called");    }

    public Student(String name, String school, double grade) {        super(name);        this.school = school;        this.grade = grade;        System.out.println("Student: constructor 2 is called");    }        private String school;    private double grade;        public String getSchool() {        return school;    }        public void setSchool(String school) {        this.school = school;    }        public double getGrade() {        return grade;    }   

Page 18: Herencia lenguaje de programacion

    public void setGrade(double grade) {        this.grade = grade;    }}

Figura-2.17: Student.java

3. Modificar InternationalStudent.java como se muestra en Código-2.18. El cambio es la llamada del método constructor de la super clase usando el método super().  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class InternationalStudent extends Student {        public InternationalStudent() {        System.out.println("InternationalStudent: constructor is called");    } 

    public InternationalStudent(String name, String school, double grade, String country) {        super(name, school, grade);        this.country = country;        System.out.println("InternationalStudent: constructor 2 is called");    }          private String country;

    public String getCountry() {        return country;    }

    public void setCountry(String country) {        this.country = country;    }    }

Código-2.18: InternationalStudent.java

4. Modificar Main.java como se muestra en Código-2.19.  El cambio consiste en crear un objeto de la clase InternationalStudent con parámetros de inicialización.  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Main {        public static void main(String[] args) {                // Create an object instance of        // InternationalStudent class.        System.out.println("---- About to create an object instance of InternationalStudent class...");        InternationalStudent internationalStudent1 =                new InternationalStudent("Sang Shin",   // Name                "1 Dreamland", // Address                4.5,           // Grade                "Korea");      // Country                System.out.println("internationalStudent1.getName() = " + internationalStudent1.getName());

Page 19: Herencia lenguaje de programacion

        System.out.println("internationalStudent1.getAddress() = " + internationalStudent1.getAddress());        System.out.println("internationalStudent1.getGrade() = " + internationalStudent1.getGrade());        System.out.println("internationalStudent1.getCountry() = " + internationalStudent1.getCountry());    }}

Código-2.19: Main.java

5. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExampleConstructorSuper y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-2.20 )

---- About to create an object instance of InternationalStudent class...Person: constructor 2 is calledStudent: constructor 2 is calledInternationalStudent: constructor 2 is calledinternationalStudent1.getName() = Sang ShininternationalStudent1.getAddress() = nullinternationalStudent1.getGrade() = 4.5internationalStudent1.getCountry() = Korea

Figura-2.20: Resultado

                                                                                                                        Volver al inicio del ejercicio 

(2.3) referencia super

Se puede el proyecto MyPeopleExample para modificarlo en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyPeopleExampleConstructorSuper2, "copiando" el proyecto MyPeopleExample - hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project. En esta sección se asume que se ha creado un nuevo proyecto.

1. Modificar Person.java como se muestra en Código-2.21. El cambio consiste en cambiar los modificadores de acceso de los campos a protected de tal manera que se puedan acceder desde las subclases.  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Person {        public Person() {        System.out.println("Person: constructor is called");    }        public Person(String name) {        this.name = name;        System.out.println("Person: constructor 2 is called");    }        protected String name;    protected String address;        public String getName() {        return name;

Page 20: Herencia lenguaje de programacion

    }        public void setName(String name) {        this.name = name;    }        public String getAddress() {        return address;    }        public void setAddress(String address) {        this.address = address;    }    }

Código-2.21: Person.java

2. Modificar Student.java como se muestra en Código-2.22. El cambio consiste en cambiar los modificadores de acceso de los campos a protected para que se puedan acceder desde las subclases.  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Student extends Person {        public Student() {        System.out.println("Student: constructor is called");    }

    public Student(String name, String school, double grade) {        super(name);        this.school = school;        this.grade = grade;        System.out.println("Student: constructor 2 is called");    }        protected String school;    protected double grade;        public String getSchool() {        return school;    }        public void setSchool(String school) {        this.school = school;    }        public double getGrade() {        return grade;    }        public void setGrade(double grade) {        this.grade = grade;    }}

Figura-2.22: Student.java

3. Modificar InternationalStudent.java como se muestra en Código-2.23.  El cambio consiste en cambiar los modificadores de acceso de los campos a protected para que se puedan acceder desde las subclases.  El fragmento de código que se require añadir se muestra en azul.

Page 21: Herencia lenguaje de programacion

package mypeopleexample;

public class InternationalStudent extends Student {        public InternationalStudent() {        System.out.println("InternationalStudent: constructor is called");    } 

    public InternationalStudent(String name, String school, double grade, String country) {        super.name = name;        super.school = school;        super.grade = grade;        this.country = country;        System.out.println("InternationalStudent: constructor 2 is called");    }          private String country;

    public String getCountry() {        return country;    }

    public void setCountry(String country) {        this.country = country;    }    }

Código-2.23: InternationalStudent.java

4. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExampleConstructorSuper2 y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-2.24)

---- About to create an object instance of InternationalStudent class...Person: contructor is calledStudent: contructor is calledInternationalStudent: contructor 2 is calledinternationalStudent1.getName() = Sang ShininternationalStudent1.getAddress() = nullinternationalStudent1.getGrade() = 4.5internationalStudent1.getCountry() = Korea

Figura-2.24: Resultado

                                                                                                                        Volver al inicio del ejercicio 

Resumen

En este ejercicio se ha visto cómo los constructores de clases relacionadas se encadenan cuando se crea una instancia de un objeto.  También se ha visto cómo usar el método super() para invocar un constructor de la clase padre.

                                                                                                                        Volver al inicio

Page 22: Herencia lenguaje de programacion

Ejercicio 3: Predominancia (Overriding) de métodos

Este ejercicio muestra el concepto de overrriding de métodos, que es posiblemente la característica más importante de la herencia Java.

1. Override de métodos

2. Runtime-polimorfismo 3. Métodos ocultos (aplica sólo a métodos estáticos)

(3.1) Override de métodos

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyPeopleExampleOverriding, "copiando" el proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  Se asume aquí que se ha creado un nuevo proyecto.

1. Modificar Person.java como se muestra en Código-3.10.  El cambio consiste en añadir un nuevo método myMethod(String t) que se priorizará por la subclase.  El fragmento de código que se require añadir se muestra en azul. Los métodos println en los constructores están comentados por simplicidad.

package mypeopleexample;

public class Person {        public Person() {        // System.out.println("Person: constructor is called");    }        public Person(String name) {        this.name = name;        // System.out.println("Person: constructor 2 is called");    }        protected String name;    protected String address;        public String getName() {        return name;    }        public void setName(String name) {        this.name = name;    }        public String getAddress() {        return address;    }        public void setAddress(String address) {        this.address = address;    }        // A method that will be overridden by sub-class    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in Person class");

Page 23: Herencia lenguaje de programacion

    }

}

Código-3.10: Person.java

2. Modificar Student.java como se muestra en Código-3.11.  El cambio consiste en modificar los modificadores de acceso de los campos a protected para que puedan ser accedidos desde la subclase.  El fragmento de código que se require añadir se muestra en azul. Los métodos println en los constructores están comentados por simplicidad.

package mypeopleexample;

public class Student extends Person {        public Student() {        // System.out.println("Student: constructor is called");    }

    public Student(String name, String school, double grade) {        super(name);        this.school = school;        this.grade = grade;        // System.out.println("Student: constructor 2 is called");    }        protected String school;    protected double grade;        public String getSchool() {        return school;    }        public void setSchool(String school) {        this.school = school;    }        public double getGrade() {        return grade;    }        public void setGrade(double grade) {        this.grade = grade;    }

    // A overriding method    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in Student class");    }

}

Figura-3.11: Student.java con método overriding

3. Modificar InternationalStudent.java como se muestra en Código-3.12.  El cambio consiste en modificar los modificadores de acceso de los campos a protected para que puedan ser accedidos desde la subclase.  El fragmento de código que se require añadir se muestra en azul. Los métodos println en los constructores están comentados por simplicidad.

package mypeopleexample;

Page 24: Herencia lenguaje de programacion

public class InternationalStudent extends Student {        public InternationalStudent() {        // System.out.println("InternationalStudent: constructor is called");    } 

    public InternationalStudent(String name, String school, double grade, String country) {        super.name = name;        super.school = school;        super.grade = grade;        this.country = country;        // System.out.println("InternationalStudent: constructor 2 is called");    }          private String country;

    public String getCountry() {        return country;    }

    public void setCountry(String country) {        this.country = country;    }

    // A overriding method    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in InternationalStudent class");    }    }

Código-3.12: InternationalStudent.java con método overriding

4. Modificar Main.java como se muestra en Código-3.13.  El cambio es crear instancias de objetos de clases Person, Student, y InternationalStudent que están relacionados a través de la herencia e invoca el método overriden myMethod() para cada uno de esas instancias.  El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Main {        public static void main(String[] args) {                System.out.println("---- Observe overriding method behavior ----");

        Person person1 = new Person();        person1.myMethod("test1");                Student student1 = new Student();        student1.myMethod("test2");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.myMethod("test3");

    }}

Código-3.13: Main.java

5. Compilar y ejecutar el programa.

Page 25: Herencia lenguaje de programacion

Hacer click con el botón derecho en el proyecto MyPeopleExampleOverriding y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-3.14 )

---- Observe overriding behavior ----myMethod(test1) in Person classmyMethod(test2) in Student classmyMethod(test3) in InternationalStudent class

Figura-3.14: Resultado

                                                                                                                        Volver al inicio del ejercicio

(3.2) Polimorfismo en Runtime

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyPeopleExampleOverridingPolymorphism, "copiando" el proyecto MyPeopleExample - hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  En lo que sigue se asume que ha creado un nuevo proyecto.

Nota: El código de ejemplo no muestra la capacidad de polimorfismo en runtime pero sí el esquema subyacente que lo permite. La capacidad del comportamiento polimórfico será explorado en otro laboratorio.

1. Modificar Main.java como se muestra en Código-3.20.  El cambio intenta observar el comportamiento polimórfico.  El fragmento de código que se require añadir se muestra en azul.

public class Main {        public static void main(String[] args) {                System.out.println("---- Observe overriding method behavior ----");                Person person1 = new Person();        person1.myMethod("test1");                Student student1 = new Student();        student1.myMethod("test2");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.myMethod("test3");                // Polymorphic behavior        System.out.println("---- Observe polymorphic behavior ----");                Person person2 = new Student();        person2.myMethod("test4");                Person person3 = new InternationalStudent();        person3.myMethod("test5");                Student student2 = new InternationalStudent();        student2.myMethod("test6");            }}

Page 26: Herencia lenguaje de programacion

Código-3.20: Main.java

2. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExampleOverridingPolymorphism y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-3.21 )

---- Observe overriding behavior ----myMethod(test1) in Person classmyMethod(test2) in Student classmyMethod(test3) in InternationalStudent class---- Observe polymorphic behavior ----myMethod(test4) in Student classmyMethod(test5) in InternationalStudent classmyMethod(test6) in InternationalStudent class

Figura-3.21: Resultado

                                                                                                                        Volver al inicio del ejercicio

(3.3) Métodos ocultos

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyPeopleExampleHidingMethods, "copiando" el proyecto MyPeopleExample - hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  En lo que sigue se asume que ha creado un nuevo proyecto.

1. Modificar Person.java como se muestra en Código-3.30.  El cambio añade un método estático que será ocultado por la subclase. El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class Person {        public Person() {        // System.out.println("Person: constructor is called");    }        public Person(String name) {        this.name = name;        // System.out.println("Person: constructor 2 is called");    }        protected String name;    protected String address;        public String getName() {        return name;    }        public void setName(String name) {        this.name = name;    }   

Page 27: Herencia lenguaje de programacion

    public String getAddress() {        return address;    }        public void setAddress(String address) {        this.address = address;    }        // A method that will be overridden by sub-class    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in Person class");    }        // A method that will be hidden by sub-class    public static void myStaticMethod(String t){        System.out.println("myStaticMethod(" + t + ") in Person class");    }    }

Código-3.30: Person.java con un método estático

2. Modificar Student.java como se muestra en Código-3.31.  El cambio añade un método estático que será ocultado por la subclase. El fragmento de código que se require añadir se muestra en azul. 

package mypeopleexample;

public class Student extends Person {        public Student() {        // System.out.println("Student: constructor is called");    }        public Student(String name, String school, double grade) {        super(name);        this.school = school;        this.grade = grade;        // System.out.println("Student: constructor 2 is called");    }        protected String school;    protected double grade;        public String getSchool() {        return school;    }        public void setSchool(String school) {        this.school = school;    }        public double getGrade() {        return grade;    }        public void setGrade(double grade) {        this.grade = grade;    }   

Page 28: Herencia lenguaje de programacion

    // A overriding method    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in Student class");    }        // A method that will be hidden by sub-class    public static void myStaticMethod(String t){        System.out.println("myStaticMethod(" + t + ") in Student class");    }}

Código-3.31: Student.java con un método static

3. Modificar InternationalStudent.java como se muestra en Código-3.32. El cambio añade un método estático que será ocultado por la subclase.   El fragmento de código que se require añadir se muestra en azul.

package mypeopleexample;

public class InternationalStudent extends Student {        public InternationalStudent() {        // System.out.println("InternationalStudent: constructor is called");    }        public InternationalStudent(String name, String school, double grade, String country) {        super.name = name;        super.school = school;        super.grade = grade;        this.country = country;        // System.out.println("InternationalStudent: constructor 2 is called");    }        private String country;        public String getCountry() {        return country;    }        public void setCountry(String country) {        this.country = country;    }        // A overriding method    public void myMethod(String t){        System.out.println("myMethod(" + t + ") in InternationalStudent class");    }        // A method that will be hidden by sub-class    public static void myStaticMethod(String t){        System.out.println("myStaticMethod(" + t + ") in InternationalStudent class");    }    }

Código-3.32: InternationalStudent.java con un método static

4. Modificar Main.java como se muestra en Código-3.33.  El cambio tiene como objetivo llamar métodos ocultos y observar el tipo de método estático invocado.   El fragmento de código que se require añadir se muestra en azul.

Page 29: Herencia lenguaje de programacion

package mypeopleexample;

public class Main {        public static void main(String[] args) {                System.out.println("---- Observe overriding behavior ----");        Person person1 = new Person();        person1.myMethod("test1");                Student student1 = new Student();        student1.myMethod("test2");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.myMethod("test3");                // Polymorphic behavior        System.out.println("---- Observe polymorphic behavior ----");        Person person2 = new Student();        person2.myMethod("test4");                Person person3 = new InternationalStudent();        person3.myMethod("test5");                Student student2 = new InternationalStudent();        student2.myMethod("test6");                // Calling hiding methods        System.out.println("---- Observe how calling hiding methods work ----");        person2.myStaticMethod("test7");        person3.myStaticMethod("test8");        student2.myStaticMethod("test9");            }}

Código-3.33: Main.java

5. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyPeopleExampleHidingMethods y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans prestando atención a la parte en negrita. (Figura-3.34 )

---- Observe overriding behavior ----myMethod(test1) in Person classmyMethod(test2) in Student classmyMethod(test3) in InternationalStudent class---- Observe polymorphic behavior ----myMethod(test4) in Student classmyMethod(test5) in InternationalStudent classmyMethod(test6) in InternationalStudent class---- Observe how calling hiding methods work ----myStaticMethod(test7) in Person classmyStaticMethod(test8) in Person classmyStaticMethod(test9) in Student class

Figura-3.34: Resultado

Page 30: Herencia lenguaje de programacion

                                                                                                                        Volver al inicio del ejercicio

Ejercicio 4: casting de tipos

En este ejercicio se mostrará el casting de tipos entre tipos de clases que están relacionadas a través de la herencia. 

1. Casting de tipo implícito 2. Casting de tipo explícito con un runtime ClassCastException 3. Casting de tipo explícito sin un runtime ClassCastException

(4.1) Casting de tipo implícito

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyPeopleExampleImplicitCasting, "copiando" el proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  En lo que sigue se asume que se ha creado un nuevo proyecto.

1. Modificar the Main.java como se muestra en Código-4.11.  El cambio consiste en añadir unas cuantas sentencias en las que se realiza el casting de tipo implícito entre tipos.

package mypeopleexample;

public class Main {        public static void main(String[] args) {                System.out.println("---- Observe overriding behavior ----");        Person person1 = new Person();        person1.myMethod("test1");                Student student1 = new Student();        student1.myMethod("test2");                InternationalStudent internationalStudent1 =                new InternationalStudent();        internationalStudent1.myMethod("test3");                // Polymorphic behavior        System.out.println("---- Observe polymorphic behavior ----");

        // This is an implicit type casting between Student and Person class.        Person person2 = new Student();   // Example 1        person2 = student1;                        // Example 2        person2.myMethod("test4");                // This is an implicit type casting between InternationalStudent and Person class.        Person person3 = new InternationalStudent();   // Example 3        person3 =  internationalStudent1;                       // Example 4        person3.myMethod("test5");                // This is an implicit type casting between InternationalStudent and Student class.

Page 31: Herencia lenguaje de programacion

        Student student2 = new InternationalStudent();  // Example 5        student2 = internationalStudent1;                        // Example 6        student2.myMethod("test6");                // Calling hiding methods        System.out.println("---- Observe how calling hiding methods work ----");        person2.myStaticMethod("test7");        person3.myStaticMethod("test8");        student2.myStaticMethod("test9");            }}

Código-4.11: Main.java

2. Compilar y ejecutar el programa

Hacer click con el botón derecho en el proyecto MyPeopleExampleImplicitCasting y seleccionar Run.

Observar el resultado en la ventana Output de NetBeans. (Figura-4.12 ) 

---- Observe overriding behavior ----myMethod(test1) in Person classmyMethod(test2) in Student classmyMethod(test3) in InternationalStudent class---- Observe polymorphic behavior ----myMethod(test4) in Student classmyMethod(test5) in InternationalStudent classmyMethod(test6) in InternationalStudent class---- Observe how calling hiding methods work ----myStaticMethod(test7) in Person classmyStaticMethod(test8) in Person classmyStaticMethod(test9) in Student class

Figura-4.12: Resultado

                                                                                                                        Volver al inicio del ejercicio

(4.2) Casting de tipo explícito con un runtime ClassCastException

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyTypeMismatchExampleProject1, "copiando" el proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  En lo que sigue se asume que se ha creado un nuevo proyecto.

1. Modificar the Main.java como se muestra en Código-4.21. 

package mytypemismatchexampleproject;

public class Main {        public static void main(String[] args) {                // Implicit casting - Student object instance is        // type of Person.        Person person1 = new Student();

Page 32: Herencia lenguaje de programacion

                // Implicit casting - Teacher object instance is        // type of Person.        Person person2 = new Teacher();                // Explicit type casting.        Student student1 = (Student) person1;                // Explicit type casting - no compile error.        // But ClassCastException will occur during runtime.        Student student2 = (Student) person2;    }    }

Código-4.21: Casting explícito con una exception potencial por mismatch en runtime

Page 33: Herencia lenguaje de programacion

2. Compilar y ejecutar el programa

Hacer click con el botón derecho en el proyecto MyTypeMismatchExampleProject1 y seleccionar Run.

Observar que se produce una excepción en tiempo de ejecución java.lang.ClassCastException.

Page 34: Herencia lenguaje de programacion

Figura-4.22: ocurrencia de java.lang.ClassCastException

                                                                                                                        Volver al inicio del ejercicio

Page 35: Herencia lenguaje de programacion

(4.3) Casting de tipo explícito sin un runtime ClassCastException

Se puede usar el proyecto MyPeopleExample para los cambios que se van a hacer en esta sección o se puede crear un nuevo proyecto, por ejemplo, MyTypeMismatchExampleProject2, "copiando" el proyecto MyPeopleExample - Hacer click con el botón derecho en el proyecto MyPeopleExample y seleccionar Copy Project.  En lo que sigue se asume que se ha creado un nuevo proyecto.

1. Modificar Main.java como se muestra en Código-4.23.  El fragmento de código que se require añadir se muestra en azul.

package mytypemismatchexampleproject;

public class Main {        public static void main(String[] args) {                // Implicit casting - Student object instance is        // type of Person.        Person person1 = new Student();                // Implicit casting - Teacher object instance is        // type of Person.        Person person2 = new Teacher();                // Explicit type casting.        Student student1 = (Student) person1;                // Do the casting only when the type is verified        if (person2 instanceof Student) {            Student student2 = (Student) person2;            System.out.println("person2 instanceof Student = " + true);        } else{            System.out.println("person2 instanceof Student = " + false);        }            }    }

Código-4.23: Uso del operador instanceOf para comprobar el tipo de la instancia del objeto

2. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyTypeMismatchExampleProject2 y seleccionar Run.

Observar el resultado en la ventana Output.  (Figura-4.24 )

person2 instanceof Student = false

Figura-4.24: Resultado

                                                                                                                        Volver al inicio del ejercicio

Resumen

En este ejercicio se ha visto cómo hacer un casting implícit y explícito entre instancias de objetos que están relacionados a través de la herencia.

Page 36: Herencia lenguaje de programacion

                                                                                                                                  Volver al inicio

Ejercicio 5: Clases Final y métodos Final

Este ejercicio muestra el concepto de clase final y método final. 

1. Compilar y ejecutar un programa Java con una clase final 2. Prueba de extender la clase String o la clase Wrapper3. Compilar y ejecutar un programa Java con un método final

(5.1) Compilar y ejecutar un programa Java con una clase final

1. Crear un proyecto NetBeans

Seleccionar File->New Project (Ctrl+Shift+N). El diálogo New Project aparece.

En la sección Choose Project seleccionar Java en la sección Categories y Java Application en la sección Projects.

Pulsar en Next.

En el campo Project Name escribir MyFinalClassExample. Click Finish.

Page 37: Herencia lenguaje de programacion

Observar que aparece el nodo del proyecto MyFinalClassExample se crea en la sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor del IDE.

2. Escribir Person.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Person. En el campo Package, escribir  myfinalclassexample o seleccionar

myfinalclassexample a partir del menú desplegable . Click Finish.

Page 38: Herencia lenguaje de programacion

Observar que se genera y muestra en la ventana del editor Person.java. Modificar Person.java como se muestra en Código-5.10.  Notar que la clase

Person es una clase final, lo que significa que no se puede extender.

package myfinalclassexample;

// Make the Person class as a final classpublic final class Person {    }

Código-5.10: Person.java como clase final

Page 39: Herencia lenguaje de programacion

3. Escribir Teacher.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

Page 40: Herencia lenguaje de programacion

En el campo Class Name escribir Teacher. En el campo Package, escribir  myfinalclassexample o seleccionar

myfinalclassexample a partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor Teacher.java. Modificar Teacher.java como se muestra en Código-5.11.  El cambio extiende la

clase Person class, lo que producirá un error de compilación.

package myfinalclassexample;

/** * * @author sang */public class Teacher extends Person{    }

Código-5.11: Teacher.java

4. Observar el error de compilación.  (Figura-5.12 )

Page 41: Herencia lenguaje de programacion

Figura-5.12: Error de compilación

                                                                                                                        Volver al inicio del ejercicio

(5.2) Prueba de extender la clase String o la clase Wrapper

Page 42: Herencia lenguaje de programacion

1. Crear un proyecto NetBeans

Seleccionar File->New Project (Ctrl+Shift+N). El diálogo New Project aparece.

En la sección Choose Project seleccionar Java en la sección Categories y Java Application en la sección Projects.

Pulsar en Next.

Observar que aparece la sección Name and Location. En el campo Project Name escribir MyFinalClassExample2. Click Finish.

Observar que aparece el nodo del proyecto MyFinalClassExample2 se crea en la sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor del IDE.

2. Escribir Teacher.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

Page 43: Herencia lenguaje de programacion

En el campo Class Name escribir Teacher. En el campo Package, escribir  myfinalclassexample2 o seleccionar

myfinalclassexample2 a partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor Teacher.java. Modificar Teacher.java como se muestra en Código-5.21.  El cambio es para

extender la clase String class, lo que produce un errror de compilación.

package myfinalclassexample2;

/** * * @author  */public class Teacher extends String{    }

Código-5.21: Teacher.java

3. Observar el error de compilación.

Page 44: Herencia lenguaje de programacion

Figura-5.22: Error de compilación

4. Mostrar Javadoc de la clase String para comprobar que la clase String es una clase final.

Mover el cursor a String y con el botón derecho seleccionar Show Javadoc.

Page 45: Herencia lenguaje de programacion

Observar que se muestra el Javadoc de la clase String. Notar que la clase String es una clase final. (Figura-5.23 )

Page 46: Herencia lenguaje de programacion
Page 47: Herencia lenguaje de programacion

Figura-5.23: Javadoc de la clase String, indica que es una clase final

t.

                                                                                                                        Volver al inicio del ejercicio

(5.3) Compilar y ejecutar un programa Java con un método final

1. Crear un proyecto NetBeans

Seleccionar File->New Project (Ctrl+Shift+N). El diálogo New Project aparece.

En la sección Choose Project seleccionar Java en la sección Categories y Java Application en la sección Projects.

Pulsar en Next.

En la sección Name and Location, del campo Project Name, escribir MyFinalMethodExample.

Click Finish.

Observar que aparece el nodo del proyecto MyFinalMethodExample se crea en la sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor del IDE.

2. Escribir Person.java.

Hacer click con el botón derecho en el proyecto MyFinalMethodExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Person. En el campo Package, escribir myfinalmethodexample o seleccionar

myfinalmethodexample a partir del menú desplegable . Click Finish.

Page 48: Herencia lenguaje de programacion

Observar que se genera y muestra en la ventana del editor Person.java. Modificar Person.java como se muestra en Código-5.30.  Notar que el método

myMethod es un método final, lo que significa que no se puede usar (override) en una subclase.

package myfinalmethodexample;

public class Person {        // myMethod() is a final method    public final void myMethod(){    }}

Código-5.30: Person.java tiene un método final

Page 49: Herencia lenguaje de programacion

3. Escribir Teacher.java.

Hacer click con el botón derecho en el proyecto MyFinalMethodExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

Page 50: Herencia lenguaje de programacion

En el campo Class Name escribir Teacher. En el campo Package, escribir   myfinalmethodexample o seleccionar

myfinalmethodexample a partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor Teacher.java. Modificar Teacher.java como se muestra en Código-5.31.  El cambio es para

que la clase Teacher derive de la clase Person y hacer un override de myMethod() de la clase Person, lo que produce un errror de compilación.

package myfinalmethodexample;

public class Teacher extends Person{       // Try to override this method    public void myMethod(){    }    }

Código-5.31: Teacher.java

4. Observar el error de compilación. (Figura-5.32 )

Page 51: Herencia lenguaje de programacion

Figura-5.32: Error de compilación

                                                                                                                        Volver al inicio del ejercicio

Resumen

Page 52: Herencia lenguaje de programacion

En este ejercicio se ha visto que una clase final no se puede derivar y que un método final no se puede hacer overridden por una subclaseb.

                                                                                                                        Volver al inicio

Ejercicio 6: Desarrollo de un programa simple que usa herencia

En este ejercicio se desarrolla un programa simple usando varias clases que están relacionadas mediante la herencia. La clase Product es heredadad por las clases Electronics y Book. La clase Electronics es derivada por las clases MP3Player y TV.  También se ve cómo añadir comportamiento polimórfico al programa a través del overriding de métodos.

1. Construir el programa MyOnlineShop

(6.1) Construir el programa MyOnlineShop

1. Crear un proyecto NetBeans

Seleccionar File->New Project (Ctrl+Shift+N). El diálogo New Project aparece.

En la sección Choose Project seleccionar Java en la sección Categories y Java Application en la sección Projects.

Pulsar en Next.

Observe that the Name and Location pane appears. For the Project Name field, enter MyOnlineShop. Hacer click en Finish.

2. Escribir Product.java.

Hacer click con el botón derecho en el proyecto MyOnlineShop y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Product. En el campo Package, escribir myonlineshop o seleccionar myonlineshopa

partir del menú desplegable . Hacer click en Finish.

Observar que se genera y muestra en la ventana del editor Product.java. Modificar Product.java como se muestra en Código-6.10.

package myonlineshop;

public class Product {        private double regularPrice;        /** Creates a new instance of Product */    public Product(double regularPrice) {        this.regularPrice = regularPrice;    }   

Page 53: Herencia lenguaje de programacion

    // Method that will be overridden    public double computeSalePrice(){        return 0;    }

    public double getRegularPrice() {        return regularPrice;    }

    public void setRegularPrice(double regularPrice) {        this.regularPrice = regularPrice;    }    }

Código-6.10: Product.java

3. Escribir Electronics.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Electronics. En el campo Package, escribir myonlineshop o seleccionar myonlineshop a

partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor Electronics.java. Modificar Electronics.java como se muestra en Código-6.11.  Notar que la clase

Electronics extiende la clase Product. 

package myonlineshop;

public class Electronics extends Product{        private String manufacturer;        /** Creates a new instance of Electronics */    public Electronics(double regularPrice,            String manufacturer) {        super(regularPrice);        this.manufacturer = manufacturer;    }        // Override this method    public double computeSalePrice(){        return super.getRegularPrice() * 0.6;    }        public String getManufacturer() {        return manufacturer;    }        public void setManufacturer(String manufacturer) {        this.manufacturer = manufacturer;    }    }

Page 54: Herencia lenguaje de programacion

Código-6.11: Electronics.java

4. Escribir MP3Player.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir MP3Player. En el campo Package, escribir myonlineshop o seleccionar myonlineshop a

partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor MP3Player.java. Modificar MP3Player.java como se muestra en Código-6.12.  Note that

MP3Player class extends Electronics class.  Notar que la clase MP3Player tiene un método computeSalePrice() que es un método overriding.

package myonlineshop;

public class MP3Player extends Electronics{        private String color;        /**     * Creates a new instance of MP3Player     */    public MP3Player(double regularPrice,                 String manufacturer,                String color) {        super(regularPrice, manufacturer);        this.color = color;    }        // Override this method    public double computeSalePrice(){        return super.getRegularPrice() * 0.9;    }

    public String getColor() {        return color;    }

    public void setColor(String color) {        this.color = color;    }}

Código-6.12: MP3Player.java

5. Escribir TV.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir TV. En el campo Package, escribir myonlineshop o seleccionar myonlineshop a

partir del menú desplegable . Click Finish.

Page 55: Herencia lenguaje de programacion

Observar que se genera y muestra en la ventana del editor TV.java. Modificar TV.java como se muestra en Código-6.14.  Notar que la clase TV

extiende la clase Electronics.  Notar también que la clase TV tiene un método computeSalePrice() que es un método overriding.

package myonlineshop;

public class TV extends Electronics {        int size;        /** Creates a new instance of TV */    public TV(double regularPrice,               String manufacturer,              int size) {        super(regularPrice, manufacturer);        this.size = size;    }        // Override this method    public double computeSalePrice(){        return super.getRegularPrice() * 0.8;    }}

Código-6.14: TV.java

6. Escribir Book.java.

Hacer click con el botón derecho en el proyecto MyFinalClassExample y seleccionar New->Java Class.

Observar que aparece el cuadro de diálogo New Java Class con la sección Name and Location.

En el campo Class Name escribir Book. En el campo Package, escribir myonlineshop o seleccionar myonlineshop a

partir del menú desplegable . Click Finish.

Observar que se genera y muestra en la ventana del editor Book.java. Modificar Book.java como se muestra en Código-6.15.  Notar que la clase Book

extiende la clase Product.  Notar que la clase Book también tiene el método computeSalePrice() que es un método overriding.

package myonlineshop;

public class Book extends Product{        private String publisher;    private int yearPublished;        /** Creates a new instance of Book */    public Book(double regularPrice,            String publisher,            int yearPublished) {        super(regularPrice);        this.publisher = publisher;        this.yearPublished = yearPublished;    }        // Override this method

Page 56: Herencia lenguaje de programacion

    public double computeSalePrice(){        return super.getRegularPrice() * 0.5;    }        public String getPublisher() {        return publisher;    }        public void setPublisher(String publisher) {        this.publisher = publisher;    }        public int getYearPublished() {        return yearPublished;    }        public void setYearPublished(int yearPublished) {        this.yearPublished = yearPublished;    }    }

Código-6.15: Book.java

7. Modificar Main.java como se muestra en Código-6.16.  Estudiar el código prestando atención a los comentarios en negrita:

package myonlineshop;

public class Main {        public static void main(String[] args) {                // Declare and create Product array of size 5        Product[] pa = new Product[5];                // Create object instances        pa[0] = new TV(1000, "Samsung", 30);        pa[1] = new TV(2000, "Sony", 50);        pa[2] = new MP3Player(250, "Apple", "blue");        pa[3] = new Book(34, "Sun press", 1992);        pa[4] = new Book(15, "Korea press", 1986);                // Compute total regular price and total        // sale price.        double totalRegularPrice = 0;        double totalSalePrice = 0;                for (int i=0; i<pa.length; i++){                        // Call a method of the super class to get            // the regular price.            totalRegularPrice += pa[i].getRegularPrice();                        // Since the sale price is computed differently            // depending on the product type, overriding            // method of the object instance of the sub-class            // gets invoked.  This is runtime polymorphic            // behavior.            totalSalePrice += pa[i].computeSalePrice();           

Page 57: Herencia lenguaje de programacion

            System.out.println("Item number " + i +                    ": Type = " + pa[i].getClass().getName() +                    ", Regular price = " + pa[i].getRegularPrice() +                    ", Sale price = " + pa[i].computeSalePrice());        }        System.out.println("totalRegularPrice = " + totalRegularPrice);        System.out.println("totalSalePrice = " + totalSalePrice);     }    }

Código-6.16: Main.java

8. Compilar y ejecutar el programa.

Hacer click con el botón derecho en el proyecto MyOnlineShop y seleccionar Run.

Observar el resultado en la ventana Output .  (Figura-6.17 )

Item number 0: Type = myonlineshop.TV, Regular price = 1000.0, Sale price = 800.0Item number 1: Type = myonlineshop.TV, Regular price = 2000.0, Sale price = 1600.0Item number 2: Type = myonlineshop.MP3Player, Regular price = 250.0, Sale price = 225.0Item number 3: Type = myonlineshop.Book, Regular price = 34.0, Sale price = 17.0Item number 4: Type = myonlineshop.Book, Regular price = 15.0, Sale price = 7.5totalRegularPrice = 3299.0totalSalePrice = 2649.5

Figura-6.17: Resultado

9. Como ejercicio, modificar MyOnlineShop como sigue:

Añadir la clase Camera como una subclase de la clase Electronics Calcular el precio de venta de Camera con la siguiente lógica de negocio

o Regular price * 0.7 En Main.java, inicializar dos objetos de la clase Camera

10. Como ejercicio, modificar MyOnlineShop como sigue:

Añadir otro método overriding a las clases como sigueo double computeSpecialCustomerPrice() o La lógica de cálculo debe ser como sigue:

Para TV, restar 100 al precio de venta Para MP3Player, restar 15 al precio de venta Para Book,restar 2 al precio de venta

En Main.java, mostrar Special Customer Price para cada artículo de los productos

Resumen

En este ejercicio se ha desarrollado un programa simple que usa varias clases que están relacionadas mediante la herencia. Se ha probado un comportamiento polimórfico a través de métodos sobrecargados.

                                                                                                                        Volver al inicio

 

 

Page 58: Herencia lenguaje de programacion

Tarea

1. Crear un proyecto NetBeans llamado "MyOwnAutoShopProject" como sigue:

Crear una superclase llamada Car.  La clase Car tiene los siguientes campos y métodos. o int speed; o double regularPrice;o String color; o double getSalePrice();

Crear una subclase de Car y llamarla Truck.  La clase Truck tiene los siguientes campos y métodos.

o int weight; o double getSalePrice();  // If weight > 2000, 10% discount. Otherwise, 20%

discount. Crear una subclase de Car y llamarla Ford.  La clase Ford tiene los siguientes campos y

métodos o int year; o int manufacturerDiscount;o double getSalePrice();  // al precio de venta calculado de la clase Car class, restar

manufacturerDiscount. Crear una subclase de Car y llamarla Sedan. La clase Sedan tiene los siguientes campos

y métodos. o int length; o double getSalePrice();  // If length > 20 feet, 5% discount, Otherwise, 10%

discount. Crear la clase MyOwnAutoShop que contiene el método main().  Realizar lo siguiente

dentro del método main().o Crear un objeto de la clase Sedan e inicializar todos los campos con valores

apropiados.  Usar el método super(...) en el constructor para inicializar los campos de la super clase.

o Crear dos objetos de la clase Ford e inicializar todos los campos con valores apropiados.  Usar super(...) en el constructor para

o Herencia (informática)o De Wikipedia, la enciclopedia libreo Saltar a: navegación, búsqueda o Para otros usos de este término, véase Herencia.o En programación orientada a objetos la herencia es, después de la agregación o

composición, el mecanismo más utilizado para alcanzar algunos de los objetivos más preciados en el desarrollo de software como lo son la reutilización y la extensibilidad. A través de ella los diseñadores pueden crear nuevas clases partiendo de una clase o de una jerarquía de clases preexistente (ya comprobadas y verificadas) evitando con ello el rediseño, la modificación y verificación de la parte ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes e implica que una subclase obtiene todo el comportamiento (métodos) y eventualmente los atributos (variables) de su superclase.

o Es la relación entre una clase general y otra clase más específica. Por ejemplo: Si declaramos una clase párrafo derivada de una clase texto, todos los métodos y variables asociadas con la clase texto, son automáticamente heredados por la subclase párrafo.

o La herencia es uno de los mecanismos de los lenguajes de programación orientada a objetos basados en clases, por medio del cual una clase se deriva de otra de manera que extiende su funcionalidad. La clase de la que se hereda se suele denominar clase base, clase padre, superclase, clase ancestro (el vocabulario que se utiliza suele depender en gran medida del lenguaje de programación).

o En los lenguajes que cuentan con un sistema de tipos fuerte y estrictamente restrictivo con el tipo de datos de las variables, la herencia suele ser un requisito fundamental para poder emplear el Polimorfismo, al igual que un mecanismo que

Page 59: Herencia lenguaje de programacion

permita decidir en tiempo de ejecución qué método debe invocarse en respuesta a la recepción de un mensaje, conocido como enlace tardío (late binding) o enlace dinámico (dynamic binding).

o Índiceo [ocultar] o 1 Ejemplo en Javao 2 Clase Abstractao 3 Herencia y ocultación de informacióno 4 Redefinición de métodoso 5 Ventajaso 6 Estereotipos de herenciao Ejemplo en Java[editar]o import javax.*;o import javax.swing.JOptionPane;o o public class Mamifero{ o private int patas;o private String nombre;o o public void imprimirPatas(){o JOptionPane.showMessageDialog(null," Tiene " + patas + " patas\n",

"Mamifero", JOptionPane.INFORMATION_MESSAGE);o }o o public Mamifero(String nombre, int patas){o this.nombre = nombre;o this.patas = patas;o }o }o o public class Perro extends Mamifero {o public Perro(String nombre){o super(nombre, 4);o }o }o o public class Gato extends Mamifero {o public Gato(String nombre){o super(nombre, 4);o }o }o o public class CrearPerro {o public static void main(String[] args) {o Perro perrito = new Perro("Pantaleon");o perrito.imprimirPatas(); /*Está en la clase mamífero*/o }o }o Se declaran las clases mamíferos, gato y perro, haciendo que gato y perro sean

unos mamíferos (derivados de esta clase), y se ve como a través de ellos se nombra al animal pero así también se accede a patas dándole el valor por defecto para esa especie.

o Es importante destacar tres cosas. La primera, es que la herencia no es un mecanismo esencial en el paradigma de programación orientada a objetos; en la mayoría de los lenguajes orientados a objetos basados en prototipos las clases no existen, en consecuencia tampoco existe la herencia y el polimorfismo se logra por otros medios. La segunda, es que el medio preferido para lograr los objetivos de extensibilidad y reutilización es la agregación o composición. La

Page 60: Herencia lenguaje de programacion

tercera, es que en lenguajes con un sistema de tipos débiles, el polimorfismo se puede lograr sin utilizar la herencia.

o Por otra parte y aunque la herencia no es un concepto indispensable en el paradigma de programación orientada a objetos, es mucho más que un mecanismo de los lenguajes basados en clases, porque implica una forma de razonar sobre cómo diseñar ciertas partes de un programa. Es decir, no sólo es un mecanismo que permite implementar un diseño, sino que establece un marco conceptual que permite razonar sobre cómo crear ese diseño.

o Clase Abstracta[editar]o La herencia permite que existan clases que nunca serán instanciadas

directamente. En el ejemplo anterior, una clase "perro" heredaría los atributos y métodos de la clase "mamífero", así como también "gato", "delfín" o cualquier otra subclase; pero, en ejecución, no habrá ningún objeto "mamífero" que no pertenezca a alguna de las subclases. En ese caso, a una clase así se la conocería como Clase Abstracta. La ausencia de instancias específicas es su única particularidad, para todo lo demás es como cualquier otra clase.

o Herencia y ocultación de información[editar]o En ciertos lenguajes, el diseñador puede definir qué variables de instancia y

métodos de los objetos de una clase son visibles. En C++ y java esto se consigue con las especificaciones private, protected y public. Sólo las variables y métodos definidos como públicos en un objeto serán visibles por todos los objetos. En otros lenguajes como Smalltalk, todas las variables de instancia son privadas y todos los métodos son públicos.

o Dependiendo del lenguaje que se utilice, el diseñador también puede controlar qué miembros de las superclases son visibles en las subclases. En el caso de java y C++ los especificadores de acceso (private, protected, public) de los miembros de la superclase afectan también a la herencia:

o Privateo Ningún miembro privado de la superclase es visible en la subclase.o Protectedo Los miembros protegidos de la superclase son visibles en la subclase, pero no

visibles para el exterior.o Publico Los miembros públicos de la superclase siguen siendo públicos en la subclase.o Redefinición de métodos[editar]o En la clase derivada se puede redefinir algún método existente en la clase base,

con el objeto de proveer una implementación diferente. Para redefinir un método en la subclase, basta con declararlo nuevamente con la misma signatura (nombre y parámetros). Si se invoca un cierto método de un objeto que no está definido en su propia clase, se dispara la búsqueda hacia arriba en la jerarquía a la que dicha clase pertenece. Sin embargo, si existieran dos métodos con la misma signatura, uno en la clase y otro en una superclase, se ejecutaría el de la clase, no el de la superclase.

o Cuando se redefine un método en una clase es posible acceder explícitamente al método original de su superclase, mediante una sintaxis específica que depende del lenguaje de programación empleado (en muchos lenguajes se trata de la palabra clave super).

o Ventajas[editar]o Ayuda a los programadores a ahorrar código y tiempo, ya que la clase padre ha

sido implementada y verificada con anterioridad, restando solo referenciar desde la clase derivada a la clase base (que suele ser extends, inherits, subclass u otras palabras clave similares, dependiendo del lenguaje).

o Los objetos pueden ser construidos a partir de otros similares. Para ello es necesario que exista una clase base (que incluso puede formar parte de una jerarquía de clases más amplia).

o La clase derivada hereda el comportamiento y los atributos de la clase base, y es común que se le añada su propio comportamiento o que modifique lo heredado.

o Toda clase pueden servir como clase base para crear otras.o Estereotipos de herencia[editar]o Herencia simple

Page 61: Herencia lenguaje de programacion

o Una clase sólo puede heredar de una clase base y de ninguna otra.o Herencia múltipleo Una clase puede heredar las características de varias clases base, es decir,

puede tener varios padres. En este aspecto hay discrepancias entre los diseñadores de lenguajes. Algunos de ellos han preferido no admitir la herencia múltiple debido a que los potenciales conflictos entre métodos y variables con igual nombre, y eventualmente con comportamientos diferentes crea un desajuste cognitivo que va en contra de los principio de la programación orientada a objetos. Por ello, la mayoría de los lenguajes orientados a objetos admite herencia simple. En contraste, algunos pocos lenguajes admiten herencia múltiple, entre ellos: C++, Python, Eiffel, mientras que Smalltalk, Java, Ada y C# sólo permiten herencia simple.

o

Herencia (informática)De Wikipedia, la enciclopedia libreSaltar a: navegación, búsqueda Para otros usos de este término, véase Herencia.

En programación orientada a objetos la herencia es, después de la agregación o composición, el mecanismo más utilizado para alcanzar algunos de los objetivos más preciados en el desarrollo de software como lo son la reutilización y la extensibilidad. A través de ella los diseñadores pueden crear nuevas clases partiendo de una clase o de una jerarquía de clases preexistente (ya comprobadas y verificadas) evitando con ello el rediseño, la modificación y verificación de la parte ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes e implica que una subclase obtiene todo el comportamiento (métodos) y eventualmente los atributos (variables) de su superclase.

Es la relación entre una clase general y otra clase más específica. Por ejemplo: Si declaramos una clase párrafo derivada de una clase texto, todos los métodos y variables asociadas con la clase texto, son automáticamente heredados por la subclase párrafo.

La herencia es uno de los mecanismos de los lenguajes de programación orientada a objetos basados en clases, por medio del cual una clase se deriva de otra de manera que extiende su funcionalidad. La clase de la que se hereda se suele denominar clase base, clase padre, superclase, clase ancestro (el vocabulario que se utiliza suele depender en gran medida del lenguaje de programación).

En los lenguajes que cuentan con un sistema de tipos fuerte y estrictamente restrictivo con el tipo de datos de las variables, la herencia suele ser un requisito fundamental para poder emplear el Polimorfismo, al igual que un mecanismo que permita decidir en tiempo de ejecución qué método debe invocarse en respuesta a la recepción de un mensaje, conocido como enlace tardío (late binding) o enlace dinámico (dynamic binding).

Índice

Page 62: Herencia lenguaje de programacion

 [ocultar] 

1 Ejemplo en Java 2 Clase Abstracta 3 Herencia y ocultación de información 4 Redefinición de métodos 5 Ventajas 6 Estereotipos de herencia

Ejemplo en Java[editar]

import javax.*;import javax.swing.JOptionPane; public class Mamifero{ private int patas; private String nombre; public void imprimirPatas(){ JOptionPane.showMessageDialog(null," Tiene " + patas + " patas\n", "Mamifero", JOptionPane.INFORMATION_MESSAGE); } public Mamifero(String nombre, int patas){ this.nombre = nombre; this.patas = patas; }} public class Perro extends Mamifero { public Perro(String nombre){ super(nombre, 4); }} public class Gato extends Mamifero { public Gato(String nombre){ super(nombre, 4); }} public class CrearPerro { public static void main(String[] args) { Perro perrito = new Perro("Pantaleon"); perrito.imprimirPatas(); /*Está en la clase mamífero*/ }}

Se declaran las clases mamíferos, gato y perro, haciendo que gato y perro sean unos mamíferos (derivados de esta clase), y se ve como a través de ellos se nombra al animal pero así también se accede a patas dándole el valor por defecto para esa especie.

Page 63: Herencia lenguaje de programacion

Es importante destacar tres cosas. La primera, es que la herencia no es un mecanismo esencial en el paradigma de programación orientada a objetos; en la mayoría de los lenguajes orientados a objetos basados en prototipos las clases no existen, en consecuencia tampoco existe la herencia y el polimorfismo se logra por otros medios. La segunda, es que el medio preferido para lograr los objetivos de extensibilidad y reutilización es la agregación o composición. La tercera, es que en lenguajes con un sistema de tipos débiles, el polimorfismo se puede lograr sin utilizar la herencia.

Por otra parte y aunque la herencia no es un concepto indispensable en el paradigma de programación orientada a objetos, es mucho más que un mecanismo de los lenguajes basados en clases, porque implica una forma de razonar sobre cómo diseñar ciertas partes de un programa. Es decir, no sólo es un mecanismo que permite implementar un diseño, sino que establece un marco conceptual que permite razonar sobre cómo crear ese diseño.

Clase Abstracta[editar]

La herencia permite que existan clases que nunca serán instanciadas directamente. En el ejemplo anterior, una clase "perro" heredaría los atributos y métodos de la clase "mamífero", así como también "gato", "delfín" o cualquier otra subclase; pero, en ejecución, no habrá ningún objeto "mamífero" que no pertenezca a alguna de las subclases. En ese caso, a una clase así se la conocería como Clase Abstracta. La ausencia de instancias específicas es su única particularidad, para todo lo demás es como cualquier otra clase.

Herencia y ocultación de información [editar]

En ciertos lenguajes, el diseñador puede definir qué variables de instancia y métodos de los objetos de una clase son visibles. En C++ y java esto se consigue con las especificaciones private, protected y public. Sólo las variables y métodos definidos como públicos en un objeto serán visibles por todos los objetos. En otros lenguajes como Smalltalk, todas las variables de instancia son privadas y todos los métodos son públicos.

Dependiendo del lenguaje que se utilice, el diseñador también puede controlar qué miembros de las superclases son visibles en las subclases. En el caso de java y C++ los especificadores de acceso (private, protected, public) de los miembros de la superclase afectan también a la herencia:

PrivateNingún miembro privado de la superclase es visible en la subclase.

ProtectedLos miembros protegidos de la superclase son visibles en la subclase, pero no visibles para el exterior.

PublicLos miembros públicos de la superclase siguen siendo públicos en la subclase.

Page 64: Herencia lenguaje de programacion

Redefinición de métodos[editar]

En la clase derivada se puede redefinir algún método existente en la clase base, con el objeto de proveer una implementación diferente. Para redefinir un método en la subclase, basta con declararlo nuevamente con la misma signatura (nombre y parámetros). Si se invoca un cierto método de un objeto que no está definido en su propia clase, se dispara la búsqueda hacia arriba en la jerarquía a la que dicha clase pertenece. Sin embargo, si existieran dos métodos con la misma signatura, uno en la clase y otro en una superclase, se ejecutaría el de la clase, no el de la superclase.

Cuando se redefine un método en una clase es posible acceder explícitamente al método original de su superclase, mediante una sintaxis específica que depende del lenguaje de programación empleado (en muchos lenguajes se trata de la palabra clave super).

Ventajas[editar]

Ayuda a los programadores a ahorrar código y tiempo, ya que la clase padre ha sido implementada y verificada con anterioridad, restando solo referenciar desde la clase derivada a la clase base (que suele ser extends, inherits, subclass u otras palabras clave similares, dependiendo del lenguaje).

Los objetos pueden ser construidos a partir de otros similares. Para ello es necesario que exista una clase base (que incluso puede formar parte de una jerarquía de clases más amplia).

La clase derivada hereda el comportamiento y los atributos de la clase base, y es común que se le añada su propio comportamiento o que modifique lo heredado.

Toda clase pueden servir como clase base para crear otras.

Estereotipos de herencia[editar]

Herencia simpleUna clase sólo puede heredar de una clase base y de ninguna otra.

Herencia múltipleUna clase puede heredar las características de varias clases base, es decir, puede tener varios padres. En este aspecto hay discrepancias entre los diseñadores de lenguajes. Algunos de ellos han preferido no admitir la herencia múltiple debido a que los potenciales conflictos entre métodos y variables con igual nombre, y eventualmente con comportamientos diferentes crea un desajuste cognitivo que va en contra de los principio de la programación orientada a objetos. Por ello, la mayoría de los lenguajes orientados a objetos admite herencia simple. En contraste, algunos pocos lenguajes admiten herencia múltiple, entre ellos: C++, Python, Eiffel, mientras que Smalltalk, Java, Ada y C# sólo permiten herencia simple.

Page 65: Herencia lenguaje de programacion

Herencia

La herencia es un mecanismo que permite la definición de una clase a partir de la definición de otra ya existente. La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos.

La herencia está fuertemente ligada a la reutilización del código en la OOP. Esto es, el código de cualquiera de las clases puede ser utilizado sin más que crear una clase derivada de ella, o bien una subclase.

Hay dos tipos de herencia: Herencia Simple y Herencia Múltiple. La primera indica que se pueden definir nuevas clases solamente a partir de una clase inicial mientras que la segunda indica que se pueden definir nuevas clases a partir de dos o más clases iniciales. Java sólo permite herencia simple.

Superclase y Subclases

El concepto de herencia conduce a una estructura jerárquica de clases o estructura de árbol, lo cual significa que en la OOP todas las relaciones entre clases deben ajustarse a dicha estructura.

En esta estructura jerárquica, cada clase tiene sólo una clase padre. La clase padre de cualquier clase es conocida como su superclase. La clase hija de una superclase es llamada una subclase.

* Una superclase puede tener cualquier número de subclases.

* Una subclase puede tener sólo una superclase.

Page 66: Herencia lenguaje de programacion

o A es la superclase de B, C y D. o D es la superclase de E. o B, C y D son subclases de A. o E es una subclase de D.