Lenguaje de Programación I: Universidad Nacional Tecnológica de Lima Sur Escuela Profesional de Ingenieria de Sistemas

UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR
ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS
Lenguaje de Programación I
Tema: Herencia y Polimorfismo
RELACIÓN DE GENERALIZACIÓN / ESPECIALIZACIÓN
La relación de generalización / especialización se da cuando dos o más clases tienen muchas de
sus partes en común (atributos y métodos) lo que normalmente se abstrae en la creación de una
nueva clase que reúne todas sus características comunes.
La relación generalización / especialización es la relación de una clase más general y una clase
más específica. La clase más específica se denomina clase hija o subclase y posee información
adicional, mientras que la clase más general se denomina clase padre o superclase.
La generalización y la especialización son diferentes perspectivas del mismo concepto, la
generalización es una perspectiva ascendente (bottom-up), mientras que la especialización es una
perspectiva descendente (top-down).
Las subclases heredan características de las clases de las que se derivan y añaden características
específicas que las diferencian. Las clases se organizan en una estructura jerárquica.
Página 1 de 31
HERENCIA
La herencia es el mecanismo mediante el cual se puede definir una clase (subclase) sobre la base
de otra clase (superclase) heredando aquellos miembros de la superclase (atributos y métodos)
que hayan sido declarados como public, protected o sin especificador de acceso. Una superclase
declara un miembro como protected para permitir el acceso al miembro desde el interior de sus
subclases y desde una clase que se encuentra en el mismo paquete, a la vez que impide el acceso
al miembro desde el exterior de la superclase. El constructor no es un miembro, por lo que no es
heredado por las subclases.
La nueva clase puede añadir nuevos miembros e incluso puede redefinir miembros de la
superclase. Redefinir un miembro de la superclase implica definir en la subclase un miembro con
el mismo nombre que el de la superclase. Esto hace que el miembro de la superclase quede oculto
en la subclase. A la redefinición de métodos se denomina también sobrescritura de métodos.
La forma general de la declaración de una clase que hereda de otra clase es la siguiente:
public class nombreDeSubclase extends nombreDeSuperclase {
// Cuerpo de la clase
}
La herencia permite establecer una jerarquía de especialización mediante la relación "es-un" o

"es-una".
Ejemplo 1:
Un Mamífero es un Animal.
Un Ave es un Animal.
Una Vaca es un Mamífero.
Un Pato es un Ave.
Lo que puede expresarse como:
class Animal {
...
Página 2 de 31
class Mamifero extends Animal {
...
class Vaca extends Mamifero {
...
class Ave extends Animal {
...
class Pato extends Ave {
...
Si una clase no tiene una superclase explícita, implícitamente su superclase es la clase Object.
Así, en el caso de la clase Animal, implícitamente figura como:
class Animal extends Object {
...
Página 3 de 31
Uso de super para invocar al constructor de la superclase
El constructor de la superclase puede invocarse desde la subclase utilizando la palabra super de
la siguiente forma:
super(lista de argumentos);
Esta instrucción tiene que ser la primera sentencia a ejecutarse dentro del constructor de la
subclase.
Ejemplo 2:
Define una superclase
package padre;
public class A {
// Atributos
public int v1; //se hereda
private int v2; //no se hereda
protected int v3; //se hereda
// Constructor
public A(int v1, int v2, int v3){ //no se hereda
this.v1=v1;
this.v2=v2;
this.v3=v3;
}
// Métodos de acceso
public int getv2(){ // se hereda
return v2;
public int getv3(){ // se hereda

return v3;
}
}
Página 4 de 31
Define una subclase

package hijo;
import padre.A;
public class B extends A{
// Atributo
public int v4;
// Constructor
public B(int v1, int v2, int v3, int v4){
//super invoca al constructor de la superclase
super(v1,v2,v3);
this.v4=v4;
}
public int suma(){

return v1+getv2()+v3+v4;
}
}
Ejemplo de uso
import hijo.B; //hay que importar la clase B del paquete hijo
// procesar es un método de la clase principal que esta fuera de los paquetes padre y hijo
void procesar(){
B r = new B(1,3,5,7);
imprimir("Objeto r de tipo B:"+r);
imprimir("V1:"+r.v1);
imprimir("V2:"+r.getv2());
// utilizamos el método getv3() heredado ya que no se
//puede emplear v3 por tener acceso protejido
imprimir("V3:"+r.getv3());
imprimir("V4:"+r.v4);
imprimir("Suma:"+r.suma());
Página 5 de 31
Ejemplo 3:
Implemente la clase Persona en el paquete padre con los siguientes miembros:
⎯ Atributos protegidos: apellidos, nombres y edad
⎯ Constructor que inicializa los atributos de la clase
⎯ Un método generarCorreo() que retorna el correo formado por el primer carácter del
nombre, el primer caracter del apellido, la edad y al final “@untels.edu.pe”.
Luego, implemente dos subclases de Persona: Docente y Alumno en el paquete hijo.
Docente presenta los siguientes miembros:
⎯ Atributos privados: horas que dicta por semana y tarifa
⎯ Constructor con parámetros para inicializar los atributos: apellidos, nombres, edad horas y
tarifa
⎯ Método calcularSueldo() que retorna horasXtarifa
Alumno presenta los siguientes miembros:

⎯ Atributos privados: tres notas de tipo double
⎯ Constructor con parámetros para inicializar los atributos: apellidos, nombres, edad y las
tres notas
⎯ Método calcularPromedio() que retorna el promedio simple de las tres notas
Página 6 de 31
Por último, implemente el método Procesar en un jFrameForm para crear objetos de Docente y
Alumno e invocar a sus métodos y a los de su superclase.
Solución:
Estructura de paquetes y clases de la aplicación:
package padre;
public class Persona {
//propiedades
protected String apellidos;
protected String nombre;
protected int edad;
//constructor
//inicializa valor de sus propiedades
public Persona(String ap, String nom, int ed) {

apellidos = ap;
nombre = nom;
edad = ed;
}
public String generarCorreo() {

return nombre.charAt(0) + apellidos.charAt(0) + edad +
"@untels.edu.pe";
}
}
Página 7 de 31
package hijo;
import padre.Persona;
public class Docente extends Persona {
//proiedades
private double horas;
private double tarifa;
//constructor
//inicializa apellidos, nombres, edad horas y tarifa
public Docente(String ap, String nom, int ed, double h, double t)
{
//invoca al constructor de la clase Persona
super(ap, nom, ed);
//asigna valor a las horas y tarifa
horas = h;
tarifa = t;
}
public double cacularSueldo() {

return horas * tarifa;
}
public String mostrarDatos() {

String cad = "Nombre:" + nombre + "\nApellidos:" + apellidos + "\n"
+ "Edad:" + edad + "\n"
+ "Horas:"+horas+"\n"
+ "Tarifa:"+tarifa+"\n"
+ "Sueldo:"+cacularSueldo();
return cad;
}
}
Página 8 de 31
package hijo;
import padre.Persona;
public class Alumno extends Persona {
//propiedades
private double nota1;
//constructor:
//inicializa apellidos, nombres, edad y las tres notas
public Alumno(String ap, String nom, int ed, double n1, double n2,
double n3) {
super(ap, nom, ed);
nota1 = n1;
nota2 = n2;
nota3 = n3;
}
public double calcularPromedio() {

return (nota1 + nota2 + nota3) / 3;
}
public String mostrarDatos() {

String cad = "Nombre:" + nombre + "\nApellidos:" + apellidos + "\n"
+ "Edad:" + edad + "\n"
+ "Nota1:" + nota1 + "\n"
+ "Nota2:" + nota2 + "\n"
+ "Nota3:" + nota3+"\n"
+ "Promedio:"+ calcularPromedio();
return cad;
}
}
Página 9 de 31
Diseño del Formulario
Codificación
public class JFramePersona extends javax.swing.JFrame {
public JFramePersona() {
initComponents();
//invocar método
desactivarCuadrosTexto(false);
}
void desactivarCuadrosTexto(boolean flat) {

txtht.setEnabled(flat);
txtt.setEnabled(flat);
txtn1.setEnabled(flat);
}
Página 10 de 31
void opcionActivar(boolean flat) {

txtht.setEnabled(flat);
txtt.setEnabled(flat);
txtn1.setEnabled(!flat);
}
void procesar(){
String nom=txtnom.getText();
String ap=txtap.getText();
int ed=Integer.parseInt(txted.getText());
if (rdsueldo.isSelected()==true){
double ht=Double.parseDouble(txtht.getText());
double t=Double.parseDouble(txtt.getText());
//instancia de la clase docente
Docente objd=new Docente(ap, nom, ed, ht, t);
//invocar a resultado
resultado(objd.mostrarDatos());
}
if (rdpromedio.isSelected()==true){
double n1=Double.parseDouble(txtn1.getText());
//instacia de la clase alumno
Alumno obja=new Alumno(ap, nom, ed, n1, n2, n3);
//Invocar a resultado
resultado(obja.mostrarDatos());
}
}
//método resultado para mostrar cuadro de dialogo
void resultado(String msg){
JOptionPane.showMessageDialog(this,msg);
}
//eventos
private void rdsueldoActionPerformed(java.awt.event.ActionEvent evt) {
opcionActivar(true);
}
private void rdpromedioActionPerformed(java.awt.event.ActionEvent

evt) {
opcionActivar(false);
}
private void btncalcularActionPerformed(java.awt.event.ActionEvent

evt) {
//invoca al método procesar
procesar();
}
Página 11 de 31
Ejecución de la aplicación:
Página 12 de 31
Opción calcular promedio: ingrese de datos y presionar botón calcular
Página 13 de 31
Opción calcular Sueldo: ingrese de datos y presionar botón calcular
Página 14 de 31
Ejemplo 4:
En una empresa de venta de artículos se necesita una aplicación que permita
controlar los sueldos de sus empleados los cuales están organizados en dos
tipos: los empleados asalariados y los de comisión, la diferencia radica en que los
asalariados tienen un sueldo fijo mensual y solo se someten a descuentos de ley
que asciende a un 10% del sueldo mensual, mientras que los de comisión tienen
una asignación mensual dependiendo del monto vendido durante el mes, existe
un monto adicional asignado a todos los empleados por comisión que tienen
más de tres años de servicio. En ambos casos los datos de los empleados son:
código, nombre, sexo, teléfono, fecha de ingreso a labores.
Página 15 de 31
Notación UML de las clases a implementar:
Súper clase
Sub clases
Implementación:
package semana2.padre;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Empleado {
//propiedades
private int codigo;
private String nombre;
private String telefono;
private String fechaingreso;
private String sexo;
Página 16 de 31
//métodos de asignación(set) y retorno(get) de valores de las

//propiedades
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {

this.codigo = codigo;
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
public String getTelefono() {

return telefono;
}
public void setTelefono(String telefono) {

this.telefono = telefono;
}
public String getFechaingreso() {

return fechaingreso;
}
public void setFechaingreso(String fechaingreso) {

this.fechaingreso = fechaingreso;
}
public String getSexo() {

return sexo;
}
public void setSexo(String sexo) {

this.sexo = sexo;
}
public int calculaAñosServicio() {

//Las clase java.util.Date usada cuando una aplicación implica el
//trabajo con fechas:
Date fechaActual = new Date();
//La clase SimpleDateFormat nos ayuda a mostrar las fechas en el
//formato que queramos o a reconstruirlas a partir de una cadena de
//texto.
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
//aplicar formato de fecha actual
String hoy = formato.format(fechaActual);
//agregar dia, mes año al arreglo data1
String[] dat1 = fechaingreso.split("/");
//agregar dia, mes año al arreglo data2
String[] dat2 = hoy.split("/");
//diferencia entre años
Página 17 de 31
int year = Integer.parseInt(dat2[2]) -

Integer.parseInt(dat1[2]);
//diferencia entre días
int mes = Integer.parseInt(dat2[1]) -
if (mes < 0) {
year = year - 1;
} else if (mes == 0) {
int dia = Integer.parseInt(dat2[0]) -
if (dia > 0) {
year = year - 1;
}
}
return year;
}
}
Página 18 de 31
package semana2.hijo;
import semana2.padre.Empleado;
public class Asalariado extends Empleado {
private double sbruto;
public double getSbruto() {

return sbruto;
}
public void setSbruto(double sbruto) {

this.sbruto = sbruto;
}
public double calculaDescuento() {

return sbruto * 0.1;
}
public double calculaNeto() {

return sbruto - calculaDescuento();
}
//constuctor
public Asalariado() {
//sueldo fijo
this.sbruto = 1800;
}
}
package semana2.hijo;
import semana2.padre.Empleado;
public class Comision extends Empleado {
private double montovendido;
public double getMontovendido() {

return montovendido;
}
public void setMontovendido(double montovendido) {

this.montovendido = montovendido;
}
public double calculaSueldo() {

double sueldo = montovendido * 0.1;
if (calculaAñosServicio() > 3) {
return sueldo + 200;
}
return sueldo;
}
}
Página 19 de 31
Frame:frmEmpleado
jFormattedTextField
jComboBox
jTextArea1
Nota: Asignar nombre de objetos del FrameForm de acuerdo a la codificación:
package semana2.gui;
import semana2.hijo.Asalariado;
public class frmAsalariado extends javax.swing.JFrame {
//métodos para capturar valores de los cuadros de texto y combobox

//
public int getCodigo() {
return Integer.parseInt(txtcodigo.getText());
}
public String getNombre() {

return txtnombre.getText();
}
public String getTelefono() {

return txttelefono.getText();
}
public String getSexo() {

return (String.valueOf(cbosexo.getSelectedItem()));
}
public String getFechaIngreso() {
return txtfechaingreso.getText();
}
Página 20 de 31
public void listaResultado(String rs){

txtresultado.append("CODIGO\tNOMBRES\tSEXO\tAÑOS DE
SERVICIO\tDESCUENTO\tNETO\n");
txtresultado.append(rs);
}
//
public frmEmpleado() {
initComponents();
//titulo del frame
setTitle("Control de Pagos");
//tamaño del frame
setSize(700, 500);
//
//Evento click del botón Registrar
private void btnregistrarActionPerformed(java.awt.event.ActionEvent
evt) {
//crear objeto de la clase Asalariado
Asalariado objAsalariado=new Asalariado();
//asignar valores a sus propiedades del objeto asalariado
objAsalariado.setCodigo(getCodigo());
objAsalariado.setNombre(getNombre());
objAsalariado.setFechaingreso(getFechaIngreso());
objAsalariado.setSexo(getSexo());
//salida de datos
String
rs=objAsalariado.getCodigo()+"\t"+objAsalariado.getNombre()+"\t"+objAs
alariado.getSexo()+"\t"+objAsalariado.calculaAñosServicio()+"\t\t"+obj
Asalariado.calculaDescuento()+"\t"+objAsalariado.calculaNeto();
listaResultado(rs);
Página 21 de 31
Ejecución de la aplicación:
Programe para calcular pago de empleados por comisión:
Página 22 de 31
Ejercicio propuesto
Un banco requiere controlar las cuentas de sus clientes y para ello las clasifica en dos:
cheques y ahorros. Todas las cuentas del banco tienen los siguientes datos:
• Número de cuenta (entero).
• Nombre del cliente (cadena).
• Saldo (numérico real).
Además, se realizan las siguientes operaciones con ellas:
• Consultar datos: A través de sus propiedades.

• Depositar: Incrementa el saldo con la cantidad de dinero que se deposita.
• Retirar: Antes de hacer el retiro, se debe verificar la suficiencia de saldo y en caso
de aprobarlo, se disminuye el saldo.
Las cuentas de ahorros presentan las siguientes características:
• Fecha de vencimiento.
• Porcentaje de interés mensual.
• Método para depositar los intereses el primer día de cada mes.
• Solamente se puede retirar dinero el día de la fecha de vencimiento.
Las cuentas de cheques presentan las siguientes características:
• Comisión por uso de chequera.
• Comisión por emisión de cheques con saldo insuficiente, la cual se descuenta
directamente del saldo.
Implemente dicho sistema con un proyecto Java
Página 23 de 31
POLIMORFISMO
En la sesión de clase anterior, la herencia se ha utilizado solamente para heredar los miembros
de una clase base, pero también existe la posibilidad de que un método de una clase derivada se
llame como método de la clase base pero tenga un funcionamiento diferente.
El polimorfismo se refiere al hecho de que un mismo método adopte múltiples formas. Esto se
consigue por medio de la sobrecarga y sobreescritura:
⎯ Sobrecarga de métodos(Overloading, polimorfismo ad-hoc): un solo nombre de método y
muchas implementaciones distintas:
a = Sumar(c,d);
a = Sumar(c,d,5);
Los métodos sobrecargados normalmente se distinguen en tiempo de compilación por tener
distintos parámetros de entrada y/o salida.
⎯ Sobreescritura (Overriding, polimorfismo de inclusión): Tipo especial de sobrecarga que
ocurre dentro de relaciones de herencia.
En este caso la signatura es la misma (refinamiento o reemplazo del método del padre) pero
los métodos se encuentran en dos clases distintas relacionadas mediante herencia.
Página 24 de 31
Utilizaré la clase Animal y Caballo para ejemplificar:
Notación de UML de las clases a implementar
Tenemos la clase animal con la siguiente estructura:
public class Animal {
public void comer(){

System.out.println("Acción de comer, genérica de un animal");
}
public void crecer(){
System.out.println("Accion de crecer, genérica de un animal");
}
}
La clase Animal tiene definidos los métodos comer y crecer, ambos son públicos y no devuelven
ningún valor, ahora declaramos la clase Caballo que heredará de Animal:
public class Caballo extends Animal{
Página 25 de 31
La clase Caballo, hereda todas las características de Animal, por lo tanto, en primer instancia,
Caballo también posee los métodos crecer y comer.
SOBRECARGAR
Lo que haremos en este momento es sobrecargar uno o los dos métodos de la clase Animal en la
clase Caballo, veamos:
/*Notemos que ambos métodos han sido declarados en la superclase

pero en esta clase hija se están redefiniendo y
colocando argumentos distintos al de la clase padre*/
//método comer sobrecargado

public void comer(String comida){
System.out.println("El caballo come: "+ comida );
}
//método crecer sobrecargado
public void crecer(long altura){
System.out.println("el caballo creció: "+ altura +" cm de altura");
}
}
Al probar la clase vemos:
package Polimorfismo;
public class Principal {
public static void main(String []args){

//instancia de la clase caballo
Caballo c = new Caballo();
c.comer();
c.comer("pasto");
c.crecer();
c.crecer(25);
}
}
Página 26 de 31
Resultado:
Notemos que podemos invocar al método comer en sus dos versiones, tanto en la superclase
como en la clase hija, en la clase padre se encuentra el método genérico y en la clase hija en método
sobrecragado. Podemos sobrecargar métodos en la misma clase tanto en la clase padre como en
la clase hija, veamos el ejemplo:
Aquí sobrecargamos los métodos en la clase padre:

System.out.println("Accion de comer, genérica de un animal");
}
//Método sobrecargado
public void comer(String comida, int kilos){
System.out.println("El animal come "+kilos+" kilos de "+comida);
}

}
public void crecer(long altura, long peso){
System.out.println("Al animal crece "+altura+" centímetros de altura y pesa “+peso+" kilos");
}
}
Página 27 de 31
y la clase hija se queda sin ningún cambio:
/*Notemos que ambos métodos han sido declarados en la superclase

pero en esta clase hija se están redefiniendo y colocando argumentos
distintos al de la clase padre*/

}
System.out.println("el caballo creció: "+ altura +" cm de altura");
}
}
Ahora probamos la clase y vemos lo siguiente:
public class Principal {
public static void main(String []args){

//instancia de la clase caballo
Caballo c = new Caballo();
c.comer();
c.comer("pasto");
c.comer("pasto",5);
c.crecer();
c.crecer(25);
c.crecer(2, 15);
}
}
Resultado:
Página 28 de 31
Notemos que podemos invocar a todos los métodos sobrecragados de ambas clases, tanto a la
clase padre, como a la clase hija.
SOBREESCRIBIR
Ahora veremos la sobre-escritura de métodos, ocuparemos la misma clase ya que podemos
mezclar ambos conceptos, recordar que la sobre-escritura de métodos tiene que ver con la
implementación del método.
Tenemos la clase animal:

System.out.println("Accion de comer, genérica de un animal");
}
System.out.println("El animal come "+kilos+" kilos de "+comida);
}
}
System.out.println("Al animal crece "+altura+" centímetros de altura y pesa
"+peso+" kilos");
}
}
Página 29 de 31
Los métodos comer y crecer, en su definición original y en su sobrecarga, podemos
sobreescribirlos, es decir, cambiar la manera en que la implementación de estos métodos se da,
veamos el ejemplo:
/*notemos que ambos métodos han sido declarados en la superclase pero en esta clase
hija se están redefiniendo y colocando argumentos distintos al de la clase padre*/

}
System.out.println("el caballo crecio: "+ altura +" cm de altura");
}
/*sobrecargas válidas para el método comer y crecer las sobrecargas están siendo en
la clase hija aunque la definición del método este en la superclase*/
private int comer(int kilos){
return 0;
}
public int comer(int kilos, String comida){
return 0;
}
private int crecer(int altura){
return 0;
}
public int crecer(int altura, long peso){
return 0;
}
//ejemplo de métodos sobre-escritos de la superclase, en la clase hija

@Override
System.out.println("Este es una sobre-escritura en la clase hija del
método comer original");
}
@Override
System.out.println("Esta es la sobre-escritura del método
sobrecargado comer en la clase hija");
}
@Override
System.out.println("Ahora esta es la sobre-escritura del método
crecer original en la clase hija");
}
@Override
System.out.println("Esta es la sobre-escritura del método crecer que
recibe dos parámetros en la clase hija");
}
}
Página 30 de 31
Vemos que tenemos la sobre-escritura tanto de los métodos originales como los sobrecargados en
la clase padre, notemos también que podemos combinar la sobrecarga y la sobre-escritura de los
métodos.
En la misma clase solamente podemos sobre-cargar métodos, pero no sobre-escribirlos, la sobre-
escritura solo se da con la herencia, es decir, solo en las clases hijas podremos implementar el
concepto de sobre-escritura.
Página 31 de 31

Lenguaje de Programación I: Universidad Nacional Tecnológica de Lima Sur Escuela Profesional de Ingenieria de Sistemas

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lenguaje de Programación I: Universidad Nacional Tecnológica de Lima Sur Escuela Profesional de Ingenieria de Sistemas

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

Tema: Herencia y Polimorfismo

RELACIÓN DE GENERALIZACIÓN / ESPECIALIZACIÓN

La relación de generalización / especialización se da cuando dos o más clases tienen muchas de

nueva clase que reúne todas sus características comunes.

La generalización y la especialización son diferentes perspectivas del mismo concepto, la

generalización es una perspectiva ascendente (bottom-up), mientras que la especialización es una

perspectiva descendente (top-down).

de otra clase (superclase) heredando aquellos miembros de la superclase (atributos y métodos)

al miembro desde el exterior de la superclase. El constructor no es un miembro, por lo que no es

heredado por las subclases.

superclase. Redefinir un miembro de la superclase implica definir en la subclase un miembro con

en la subclase. A la redefinición de métodos se denomina también sobrescritura de métodos.

public class nombreDeSubclase extends nombreDeSuperclase {

La herencia permite establecer una jerarquía de especialización mediante la relación "es-un" o

Una Vaca es un Mamífero.

Lo que puede expresarse como:

class Mamifero extends Animal {

class Vaca extends Mamifero {

class Ave extends Animal {

class Pato extends Ave {

Así, en el caso de la clase Animal, implícitamente figura como:

class Animal extends Object {

Uso de super para invocar al constructor de la superclase

El constructor de la superclase puede invocarse desde la subclase utilizando la palabra super de

public int v1; //se hereda

private int v2; //no se hereda

protected int v3; //se hereda

public A(int v1, int v2, int v3){ //no se hereda

public int getv2(){ // se hereda

public int getv3(){ // se hereda

Define una subclase

public int suma(){

import hijo.B; //hay que importar la clase B del paquete hijo

imprimir("Objeto r de tipo B:"+r);

// utilizamos el método getv3() heredado ya que no se

//puede emplear v3 por tener acceso protejido

Implemente la clase Persona en el paquete padre con los siguientes miembros:

⎯ Atributos protegidos: apellidos, nombres y edad

⎯ Constructor que inicializa los atributos de la clase

Luego, implemente dos subclases de Persona: Docente y Alumno en el paquete hijo.

Docente presenta los siguientes miembros:

⎯ Atributos privados: horas que dicta por semana y tarifa

⎯ Método calcularSueldo() que retorna horasXtarifa

Alumno presenta los siguientes miembros:

⎯ Método calcularPromedio() que retorna el promedio simple de las tres notas

Alumno e invocar a sus métodos y a los de su superclase.

Estructura de paquetes y clases de la aplicación:

public class Persona {

public Persona(String ap, String nom, int ed) {

public String generarCorreo() {

public class Docente extends Persona {

public double cacularSueldo() {

public String mostrarDatos() {

public class Alumno extends Persona {

public double calcularPromedio() {

public String mostrarDatos() {

Diseño del Formulario

public class JFramePersona extends javax.swing.JFrame {

void desactivarCuadrosTexto(boolean flat) {

void opcionActivar(boolean flat) {

private void rdpromedioActionPerformed(java.awt.event.ActionEvent