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.

Compilar y ejecutar un programa Java que usa clases relacionadas
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.

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

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.

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.
- 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;
    }

    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.

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;
    }

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

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.

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

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.

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() = Beatles
Displaying 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.

Cadena de llamada a Constructor
método super()
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 {

    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;
    }
}

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.

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 called
Student: constructor is called
InternationalStudent: constructor is called
---- About to create an object instance of Teacher class...
Person: constructor is called
Teacher: 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) {
        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;
    }

    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());
        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 called
Student: constructor 2 is called
InternationalStudent: constructor 2 is called
internationalStudent1.getName() = Sang Shin
internationalStudent1.getAddress() = null
internationalStudent1.getGrade() = 4.5
internationalStudent1.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;
    }

    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.

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 called
Student: contructor is called
InternationalStudent: contructor 2 is called
internationalStudent1.getName() = Sang Shin
internationalStudent1.getAddress() = null
internationalStudent1.getGrade() = 4.5
internationalStudent1.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

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.

Override de métodos
Runtime-polimorfismo
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");
    }

}

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;

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.

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 class
myMethod(test2) in Student class
myMethod(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");

    }
}

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 )

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.

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.

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.

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.

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 class
myMethod(test2) in Student class
myMethod(test3) in InternationalStudent class
---- Observe polymorphic behavior ----
myMethod(test4) in Student class
myMethod(test5) in InternationalStudent class
myMethod(test6) in InternationalStudent class
---- Observe how calling hiding methods work ----
myStaticMethod(test7) in Person class
myStaticMethod(test8) in Person class
myStaticMethod(test9) in Student class

Figura-3.34: Resultado

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.

Casting de tipo implícito
Casting de tipo explícito con un runtime ClassCastException
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.
        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 )

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();

        // 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

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.

Figura-4.22: ocurrencia de java.lang.ClassCastException

Volver al inicio del ejercicio

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

Volver al inicio

Ejercicio 5: Clases Final y métodos Final

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

Compilar y ejecutar un programa Java con una clase final
Prueba de extender la clase String o la clase Wrapper
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.

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.

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 class
public final class Person {

}

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

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

Figura-5.12: Error de compilación

Volver al inicio del ejercicio

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

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

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.

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

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.

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

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

Figura-5.32: Error de compilación

Volver al inicio del ejercicio

Resumen

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.

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;
    }

    // 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;
    }

}

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.

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
    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();

            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.0
Item number 1: Type = myonlineshop.TV, Regular price = 2000.0, Sale price = 1600.0
Item number 2: Type = myonlineshop.MP3Player, Regular price = 250.0, Sale price = 225.0
Item number 3: Type = myonlineshop.Book, Regular price = 34.0, Sale price = 17.0
Item number 4: Type = myonlineshop.Book, Regular price = 15.0, Sale price = 7.5
totalRegularPrice = 3299.0
totalSalePrice = 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
- 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 sigue
- double computeSpecialCustomerPrice()
- 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

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.
- int speed;
- double regularPrice;
- String color;
- double getSalePrice();
Crear una subclase de Car y llamarla Truck. La clase Truck tiene los siguientes campos y métodos.
- int weight;
- 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
- int year;
- int manufacturerDiscount;
- 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.
- int length;
- 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().
- 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.
- Crear dos objetos de la clase Ford e inicializar todos los campos con valores apropiados. Usar super(...) en el constructor para inicializar los campos de la super clase.
- Crear un objeto de la clase Car e inicializar todos los campos con valores apropiados.
Mostrar los precios de venta de todas las instancias.