NOMBRE DEL ALUMNO: ___________________________________________

PRÁCTICA 11: ____________EJERCICIOS DE ABSTRACCIÓN_____________

Ejercicio 1: Clase Abstracta

En este ejercicio se escribirá un programa Java que usa clases abstractas. También se
expondrá cómo añadir comportamiento polimórfico al programa a través de métodos
abstractos.

1. Compilar y ejecutar una aplicación que usa una clase abstracta

2. Desarrollo del proyecto MyOnlineShopUsingAbstractClass

(1.1) Compilar y ejecutar una aplicación que usa una clase abstracta

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 MyAbstractClassProject. (Figura-1.10)
 Click en Finish.
Figura-1.10: Creación del proyecto

 Observar que aparece el nodo del proyecto MyAbstractClassProject en la

sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor
del IDE.

2. Escribir LivingThing.java como una clase abstracta.

 Hacer click con el botón derecho en el proyecto MyAbstractClassProject 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 LivingThing.
 En el campo Package, escribir myabstractclassproject o
seleccionar myabstractclassproject a partir del menú desplegable. (Figura-1.11)
 Click en Finish.
Figura-1.11: Clase abstracta LivingThing

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

 Modificar LivingThing.java como se muestra en Código-1.12.
 Estudiar el código prestando atención al texto en negrita.

package myabstractclassproject;

// The LivingThing class is an abstract class because

// some methods in it are declared as abstract methods.
public abstract class LivingThing {

private String name;

public LivingThing(String name){

this.name = name;
}

public void breath(){

System.out.println("Living Thing breathing...");
}

public void eat(){

System.out.println("Living Thing eating...");
}
 /**
* Abstract method walk()
* We want this method to be implemented by subclasses of
* LivingThing
*/
public abstract void walk();

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}
}
Código-1.12: LivingThing.java

3. Escribir Human.java. Human.java es una clase concreta que extiende la clase

abstracta LivingThing.

 Hacer click con el botón derecho en el proyecto MyAbstractClassProject 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 Human.
 En el campo Package, escribir myabstractclassproject o
seleccionar myabstractclassprojecta partir del menú desplegable.
 Click en Finish.

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

 Modificar Human.java como se muestra en Código-1.13.
 Estudiar el código prestando atención al texto en negrita.

package myabstractclassproject;

public class Human extends LivingThing {

public Human(String name){

super(name);
}

// Provide implementation of the abstract method.

public void walk(){
System.out.println("Human " + getName() + " walks...");
}

}
Código-1.13: Human.java

4. Escribir Monkey.java. (Código-1.14)

 package myabstractclassproject;

public class Monkey extends LivingThing {

public Monkey(String name){

super(name);
}

// Implement the abstract method

public void walk(){
System.out.println("Monkey " + getName() + " also walks...");
}
}
Código-1.14: Monkey.java

5. Modificar Main.java como se muestra en Código-1.15. Estudiar el código prestando atención

al texto en negrita.

package myabstractclassproject;

public class Main {

public static void main(String[] args) {

// Create Human object instance

// and assign it to Human type.
Human human1 = new Human("Sang Shin");
human1.walk();

// Create Human object instance

// and assign it to LivingThing type.
LivingThing livingthing1 = human1;
livingthing1.walk();

// Create a Monkey object instance

// and assign it to LivingThing type.
LivingThing livingthing2 = new Monkey("MonkeyWrench");
livingthing2.walk();

// Display data from human1 and livingthing1.

// Observe that they refer to the same object instance.
System.out.println("human1.getName() = " + human1.getName());
System.out.println("livingthing1.getName() = " + livingthing1.getName());

// Check of object instance that is referred by x and

// y is the same object instance.
boolean b1 = (human1 == livingthing1);
System.out.println("Do human1 and livingthing1 point to the same object instance? " +
b1);

// Compile error
// LivingThing z = new LivingThing();
}

}
Código-1.15: Main.java
6. Compilar y ejecutar el programa.

 Hacer click con el botón derecho en el proyecto MyAbstractClassProject y

seleccionar Run.
 Observar el resultado en la ventana Output de NetBeans. (Figura-1.16)

Human Sang Shin walks...

Human Sang Shin walks...
Monkey MonkeyWrench also walks...
human1.getName() = Sang Shin
livingthing1.getName() = Sang Shin
Do human1 and livingthing1 point to the same object instance? True
Figura-1.16: Resultado

(1.2) Desarrollo del proyecto MyOnlineShopUsingAbstractClass

En este paso se va a reescribir el programa MyOnlineShop que se compiló y ejecutó en

el Laboratorio Java Inheritance para usar un método abstracto de una clase abstracta
(en lugar de overriding un método de una clase concreta). Las diferencias se muestran
en negrita.

Las siguientes instrucciones asumen que se parte de cero.

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 MyOnlineShopUsingAbstractClass.
 Click en Finish.

 Observar que aparece el nodo del proyecto MyOnlineShopUsingAbstractClass en la

sección Projects del IDE NetBeans y que se muestra Main.java en la ventana del editor
del IDE.

2. Escribir Product.java. La clase Product es una clase abstracta que tiene un método
abstracto llamado computeSalePrice().

 Hacer click con el botón derecho en el proyecto MyOnlineShopUsingAbstractClass 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.
 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-1.20.
 package myonlineshop;

// Product class is now an abstract class

public abstract class Product {

private double regularPrice;

/** Creates a new instance of Product */

public Product(double regularPrice) {
this.regularPrice = regularPrice;
}

// computeSalePrice() is now an abstract method

public abstract double computeSalePrice();

public double getRegularPrice() {

return regularPrice;
}

public void setRegularPrice(double regularPrice) {

this.regularPrice = regularPrice;
}

}
Código-1.20: Product.java

3. Escribir Electronics.java. La clase Electronics es una clase abstracta porque no proporciona

implementación del método abstracto computeSalePrice().

 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 en Finish.

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

 Modificar Electronics.java como se muestra en Código-1.21. Notar que la clase
Electronics extiende la clase Product.

package myonlineshop;

// Electronics class is now an abstract class because

// it does not provide implementation of the
// computeSalePrice() abstract method.
public abstract class Electronics extends Product{

private String manufacturer;

/** Creates a new instance of Electronics */

public Electronics(double regularPrice,
String manufacturer) {
super(regularPrice);
 this.manufacturer = manufacturer;
}

public String getManufacturer() {

return manufacturer;
}

public void setManufacturer(String manufacturer) {

this.manufacturer = manufacturer;
}

}
Código-1.21: Electronics.java

4. Escribir MP3Player.java. La clase MP3Player extiende la clase Electronics. Notar también

que la clase MP3Player tiene la implementación del método computeSalePrice().

 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 en Finish.

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

 Modificar MP3Player.java como se muestra en Código-1.23.

package myonlineshop;

public class MP3Player extends Electronics{

private String color;

public MP3Player(double regularPrice,

String manufacturer,
String color) {
super(regularPrice, manufacturer);
this.color = color;
}

// Implement the abstract method

public double computeSalePrice(){
return super.getRegularPrice() * 0.9;
}

public String getColor() {

return color;
}

public void setColor(String color) {

this.color = color;
 }
}
Código-1.23: MP3Player.java

5. Escribir TV.java. La clase TV extiende la clase abstracta Electronics. Notar también que la
clase TV tiene la implementación del método computeSalePrice().

 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 en Finish.

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

 Modificar TV.java como se muestra en Código-1.24.

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

// Implement the abstract method

public double computeSalePrice(){
return super.getRegularPrice() * 0.8;
}
}
Código-1.24: TV.java

6. Escribir Book.java. La clase Book extiende la clase Product. Notar también que la
clase Book tiene la implementación del método computeSalePrice().

 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 en Finish.

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

 Modificar Book.java como se muestra en Código-1.25.
 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;
}

// Implement the abstract 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-1.25: Book.java

7. Modificar Main.java como se muestra en Código-1.26. 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 and assign them to

// the type of Product.
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 (implementation)
// 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-1.26: Main.java

8. Compilar y ejecutar el programa.

 Hacer click con el botón derecho en el proyecto MyOnlineShopUsingAbstractClass y

seleccionar Run.
 Observar el resultado en la ventana Output de NetBeans. (Figura-1.27)

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-1.27: Resultado