MINISTERIO DE EDUCACIÓN

INSTITUTO SUPERIOR C&C TECHNOLOGIES

TÉCNICO EN TECNOLOGÍA INFORMÁTICO
PROGRAMACIÓN II

ACTIVIDAD III

PROFESORA
DAILYS RODRIGUEZ

PARTICIPANTE
GABRIELA M. REYES MOJICA

CÉDULA
10-709-2410

2022
 INTRODUCCIÓN

En este presente trabajo explicare un poco sobre la Herencia aplicado a Java y el Polimorfismo
aplicado a Java.

La herencia permite compartir automáticamente métodos y datos entre clases, subclases y

objetos.

El polimorfismo es la capacidad que tienen ciertos lenguajes para hacer que, al enviar el mismo
mensaje desde distintos objetos, cada uno de esos objetos pueda responder a ese mensaje de
forma distinta.

En el primer punto sobre el concepto de la herencia aplicada a java y ventajas, dentro del tema
unos subpuntos como: ejemplo como usar la herencia en java, control de acceso en herencia a
java, control de acceso a miembro a herencia, constructores y herencias, tipos de herencia en
java, datos importantes acerca de la herencia en java y por último que se puede hacer en una
subclase.

En el segundo punto explicar el concepto sobre polimorfismo y los tres tipos de polimorfismo
que existen.

Y por último una breve conclusión.

1. Concepto de Herencia aplicado a Java
Podemos definir la herencia como la capacidad de crear clases que adquieren de manera
automática los miembros (atributos y métodos) de otras clases que ya existen, pudiendo
al mismo tiempo añadir atributos y métodos propios.
Entre las principales ventajas que ofrece la herencia en el desarrollo de aplicaciones,
están:
 Reutilización del código: en esos casos donde es necesario generar una clase
que, además de otros propios, deba integrar los procedimientos definidos en otra,
la herencia previene tener que reescribir todos aquellos procedimientos en la
nueva clase.
 Mantenimiento de aplicaciones existentes: usando la herencia, si poseemos una
clase con una cierta funcionalidad y poseemos la necesidad de expandir esa
funcionalidad, no requerimos cambiar la clase que existe (la cual se puede
continuar usando para el tipo de programa para la que ha sido diseñada) sino que
tenemos la posibilidad de generar una clase que herede a la primera, adquiriendo
toda su funcionalidad y agregando la suya propia.

1.1. Ejemplo de cómo usar la herencia en Java.

La palabra clave utilizada para la herencia es extends.
Ejemplo: Comencemos con un breve ejemplo que ilustra varias de las características
clave de la herencia. El siguiente programa crea una superclase llamada
DosDimensiones, que almacena el ancho y la altura de un objeto bidimensional, y una
subclase llamada Triangulo. Observe cómo se usa la palabra clave extends para crear
una subclase.

//Clase para objetos de dos dimensiones

class DosDimensiones{
double base;
double altura;
void mostrarDimension(){
System.out.println("La base y altura es: "+base+" y "+altura);
}
//Una subclase de DosDimensiones para Triangulo
class Triangulo extends DosDimensiones{
String estilo;
double area(){
return base*altura/2;
}
void mostrarEstilo(){
System.out.println("Triangulo es: "+estilo);
}
}
class Lados3{
public static void main(String[] args) {
Triangulo t1=new Triangulo();
Triangulo t2=new Triangulo();
t1.base=4.0;
t1.altura=4.0;
t1.estilo="Estilo 1";
t2.base=8.0;
t2.altura=12.0;
t2.estilo="Estilo 2";
System.out.println("Información para T1: ");
t1.mostrarEstilo();
t1.mostrarDimension();
System.out.println("Su área es: "+t1.area());
System.out.println();
System.out.println("Información para T2: ");
t2.mostrarEstilo();
t2.mostrarDimension();
System.out.println("Su área es: "+t2.area());
}
 Salida:

Información para T1:

Triangulo es: Estilo 1
La base y altura es: 4.0 y 4.0
Su área es: 8.0
Información para T2:
Triangulo es: Estilo 2
La base y altura es: 8.0 y 12.0
Su área es: 48.0

Tenga en cuenta que durante la herencia solo se crea el objeto de la subclase, no de la

superclase.

1.2. Control de Acceso a Miembros en Herencia

Comunmente una variable de instancia de una clase se declarará privada (private) para
evadir su uso no autorizado o variación. Heredar una clase no anula la restricción de
ingreso privado. Por consiguiente, aunque una subclase incluye a todos los miembros de
su superclase, no puede entrar a los miembros de la superclase que se han proclamado
privados.
Por ejemplo, si, como se muestra aquí, la base y la altura se vuelven privados en Dos
Dimensiones, entonces Triangulo no podrá acceder a ellos.
Ejemplo:
//Clase para objetos de dos dimensiones
class DosDimensiones{
private double base;
private double altura;
 void mostrarDimension(){
System.out.println("La base y altura es: "+base+" y "+altura);
}
}
//Una subclase de DosDimensiones para Triangulo
class Triangulo extends DosDimensiones{
String estilo;
double area(){
return base*altura/2; //Error! no se puede acceder
}
void mostrarEstilo(){
System.out.println("Triangulo es: "+estilo);
}
}
La clase Triangulo no se compilará ya que la alusión a la base y elevación dentro del
procedimiento area() causa una infracción de ingreso. Como la base y elevación se
declaran privados, solo son disponibles para los demás miembros de su propia clase. Las
subclases no poseen ingreso a ellas.
Recuerde que un integrante de la clase que fue proclamado private seguirá siendo
privado para su clase. No es accesible por ningún código fuera de su clase, incluidas las
subclases.
Al inicio, podría pensar que el hecho de que las subclases no tengan ingreso a los
miembros privados de las superclases es una restricción seria que impediría la utilización
de miembros privados en muchas situaciones. No obstante, aquello no es verdad. Los
programadores de Java acostumbran a usar procedimientos de ingreso para proveer
ingreso a los miembros privados de una clase.

Aquí hay una reescritura de las clases DosDimensiones y Triangulo que usa métodos
para acceder a las variables de instancia privadas base y altura:
//Clase para objetos de dos dimensiones
class DosDimensiones{
 private double base;
private double altura;
//Métodos de acceso para base y altura
double getBase(){return base;}
double getAltura(){return altura;}
void setBase(double b){base=b;}
void setAltura (double h){altura=h;}
void mostrarDimension(){
System.out.println("La base y altura es: "+base+" y "+altura);
}
}

//Una subclase de DosDimensiones para Triangulo

class Triangulo extends DosDimensiones{
String estilo;
double area(){
return getBase()*getAltura()/2;
}
void mostrarEstilo(){
System.out.println("Triangulo es: "+estilo);
}
}
class Lados3{
public static void main(String[] args) {
Triangulo t1=new Triangulo();
Triangulo t2=new Triangulo();
t1.setBase(4.0);
t1.setAltura(4.0);
t1.estilo="Estilo 1";
t2.setBase(8.0);
t2.setAltura(12.0);
 t2.estilo="Estilo 2";
System.out.println("Información para T1: ");
t1.mostrarEstilo();
t1.mostrarDimension();
System.out.println("Su área es: "+t1.area());
System.out.println();
System.out.println("Información para T2: ");
t2.mostrarEstilo();
t2.mostrarDimension();
System.out.println("Su área es: "+t2.area());
}
}

Salida:

Información para T1:

Triangulo es: Estilo 1
La base y altura es: 4.0 y 4.0
Su área es: 8.0
Información para T2:
Triangulo es: Estilo 2
La base y altura es: 8.0 y 12.0
Su área es: 48.0

1.3. Constructores y herencia

En una jerarquía, es posible que tanto las superclases como las subclases tengan sus
propios constructores. Esto plantea una pregunta importante: ¿qué constructor es
responsable de construir un objeto de la subclase, el de la superclase, el de la subclase o
ambos? La respuesta es esta: el constructor para la superclase construye la porción de la
superclase del objeto, y el constructor para la subclase construye la parte de la subclase.
Esto tiene sentido porque la superclase no tiene conocimiento ni acceso a ningún
elemento en una subclase. Por lo tanto, su construcción debe estar separada. En la
práctica, la mayoría de las clases tendrán constructores explícitos (no predeterminados).
Aquí verá cómo manejar esta situación.

Cuando solo la subclase define un constructor, el proceso es sencillo: simplemente

construye el objeto de la subclase. La porción de superclase del objeto se construye
automáticamente utilizando su constructor predeterminado. Por ejemplo, aquí hay un
programa para Triangulo que define un constructor. También hace que el estilo sea
privado, ya que ahora lo establece el constructor.
//Clase para objetos de dos dimensiones
//DosDimensiones.java
class DosDimensiones{
private double base;
private double altura;
//Métodos de acceso para base y altura
double getBase(){return base;}
double getAltura(){return altura;}
void setBase(double b){base=b;}
void setAltura (double h){altura=h;}
void mostrarDimension(){
System.out.println("La base y altura es: "+base+" y "+altura);
}
}
//Una subclase de DosDimensiones para Triangulo
//Triangulo.java
class Triangulo extends DosDimensiones{
private String estilo;
//Constructor
Triangulo(String s, double b, double h){
setBase(b);
 setAltura(h);
estilo=s;
}
double area(){
return getBase()*getAltura()/2;
}
void mostrarEstilo(){
System.out.println("Triangulo es: "+estilo);
}
}
class Lados3{
public static void main(String[] args) {
Triangulo t1=new Triangulo("Estilo 1",4.0,4.0);
Triangulo t2=new Triangulo("Estilo 2",8.0,12.0);
System.out.println("Información para T1: ");
t1.mostrarEstilo();
t1.mostrarDimension();
System.out.println("Su área es: "+t1.area());
System.out.println();
System.out.println("Información para T2: ");
t2.mostrarEstilo();
t2.mostrarDimension();
System.out.println("Su área es: "+t2.area());
}
}

Salida:
Información para T1:
Triangulo es: Estilo 1
La base y altura es: 4.0 y 4.0
Su área es: 8.0
 Información para T2:
Triangulo es: Estilo 2
La base y altura es: 8.0 y 12.0
Su área es: 48.0
Aquí, el constructor de Triangulo inicializa los miembros de DosDimensiones que
hereda, junto con su propio campo de estilo.
Cuando tanto la superclase como la subclase definen constructores, el proceso es un
poco más complicado porque deben ejecutarse tanto la superclase como los
constructores de subclase. En este caso, debe usar otra de las palabras clave de Java,
super, que tiene dos formas generales.
 El primero llama a un constructor de superclase.
 El segundo se usa para acceder a un miembro de la superclase que ha sido
ocultado por un miembro de una subclase.

1.4. Tipos de herencia en Java

 Herencia única: en la herencia única, las subclases heredan las características de
solo una superclase.
 Herencia Multinivel: en la herencia multinivel, una clase derivada heredará una
clase base y, además, la clase derivada también actuará como la clase base de
otra clase. En la imagen inferior, la clase A sirve como clase base para la clase
derivada B, que a su vez sirve como clase base para la clase derivada C. En Java,
una clase no puede acceder directamente a los miembros de los “abuelos”.
 Herencia Jerárquica: en la herencia jerárquica, una clase sirve como una
superclase (clase base) para más de una subclase. En la imagen inferior, la clase
A sirve como clase base para la clase derivada B, C y D.
 Herencia Múltiple (a través de interfaces): en Herencia múltiple, una clase puede
tener más de una superclase y heredar características de todas las clases
principales. Tenga en cuenta que Java no admite herencia múltiple con clases. En
Java, podemos lograr herencia múltiple solo a través de Interfaces. En la imagen
a continuación, la Clase C se deriva de la interfaz A y B.
  Herencia Híbrida (a través de Interfaces): Es una mezcla de dos o más de los
tipos de herencia anteriores. Como Java no admite herencia múltiple con clases,
la herencia híbrida tampoco es posible con clases. En Java, podemos lograr
herencia híbrida solo a través de Interfaces.

1.5. Datos importantes acerca de la herencia en Java

 La superclase solo podría ser una: una superclase puede tener cualquier
proporción de subclases. Sin embargo, una subclase solo puede tener una
superclase. Esto se debería a que Java no admite herencia múltiple con clases.
Aunque con interfaces, la herencia múltiple es compatible con java.
 Heredar constructores: una subclase hereda todos los miembros (campos,
procedimientos y clases anidadas) de su superclase. Los constructores no son
miembros, por lo cual no son heredados por subclases, empero el constructor de
la superclase puede invocarse a partir de la subclase.

1.6. ¿Qué se puede hacer en una Subclase?

En las subclases tenemos la posibilidad de heredar los miembros de la misma forma que
permanecen, reemplazarlos, ocultarlos o complementarlos con nuevos miembros:
 Podemos escribir un nuevo método de instancia en la subclase que tenga la
misma firma que el de la superclase, anulándolo (como en el ejemplo anterior, el
método toString() se reemplaza).
 Se puede escribir un nuevo método estático en la subclase que tiene la misma
firma que el de la superclase, escondiéndolo así.
 Los métodos heredados pueden usar de forma directa tal como son.
 Podemos declarar nuevos métodos en la subclase que no están en la superclase.

2. Concepto de polimorfismo aplicado a Java

En programación orientada a objetos, polimorfismo es la capacidad que tienen los objetos
de una clase en ofrecer respuesta distinta e independiente en función de los parámetros
(diferentes implementaciones) utilizados durante su invocación.
Existen 3 tipos de polimorfismo:
2.2. Polimorfismo Paramétrico
Existen funciones con el mismo nombre, pero se usan diferentes parámetros (nombre o
tipo). Se selecciona el método dependiendo del tipo de datos que se envíe.
Aquí el método demo () se sobrecarga 3 veces: el primer método tiene 1 parámetro int, el
segundo método tiene 2 parámetros int y el tercero tiene un parámetro doble. Por lo que
para lidiar con esta variedad el método que se llamará está determinado por los
argumentos que pasamos al llamar a los métodos. Esto sucede en tiempo de compilación
en tiempo de ejecución, por lo que este tipo de polimorfismo se conoce también como
polimorfismo en tiempo de compilación.
class Overload
{
void demo (int a)
{
System.out.println ("a: " + a);
}
void demo (int a, int b)
{
System.out.println ("a and b: " + a + "," + b);
}
double demo(double a) {
System.out.println("double a: " + a);
return a*a;
}
}
class MethodOverloading
{
public static void main (String args [])
{
Overload Obj = new Overload();
double result;
 Obj .demo(10);
Obj .demo(10, 20);
result = Obj .demo(5.5);
System.out.println("O/P : " + result);
}
}
Salida de datos:
a: 10
a and b: 10,20
double a: 5.5
O/P : 30.25

2.3. Polimorfismo de Inclusión

Es cuando se puede llamar a un método sin tener que conocer su tipo, así no se toma en
cuenta los detalles de las clases especializadas, utilizando una interfaz común.
En él, una subclase define un método que existe en una superclase con una lista de
argumentos (si se define otra lista de argumentos, estaríamos haciendo sobrecarga y no
redefinición).
Un ejemplo muy básico en donde la clase Bishop sobreescribe el método move. Esto es el
polimorfismo de inclusión.
abstract class Piece{
public abstract void move(byte X, byte Y);
}
class Bishop extends Piece{
@Override
public void move(byte X, byte Y){
}
}

2.4. Polimorfismo de Sobrecarga

El más conocido y se aplica cuando existen funciones con el mismo nombre en clases
que son completamente independientes una de la otra.
Diferencia entre polimorfismo y sobrecarga
El polimorfismo muestra unas claras ventajas aplicado a partir de las interfaces, debido a
que nos posibilita producir nuevos tipos sin necesidad de cambiar las clases ya existentes.
Basta con recompilar todo el código que incluye los nuevos tipos añadidos sin retocar la
clase antes construida para adicionar una totalmente nueva utilización lo cual podría dar
por sentado una revisión completa de todo el código donde se instancia la clase.
Por contra, un procedimiento está sobrecargado si en una clase hay 2 o más
declaraciones de dicho procedimiento con el mismo nombre empero con fronteras
diversos, por lo cual no se debe confundirlo con polimorfismo.
Esto puede parecer un poco confuso sin embargo en conclusión el Polimorfismo se
apoya en redefinir un procedimiento de una clase papá en una clase hija. Mientras tanto
que sobrecarga es conceptualizar un nuevo procedimiento igual que otro viejo, empero
cambiando el tipo o la proporción de fronteras.
El compilador, viendo las fronteras, sabe a qué procedimiento llamar en funcionalidad
del parámetro que estás pasando. La sobrecarga se resuelve en tiempo de compilación
usando los nombres de los procedimientos y los tipos de sus fronteras; el polimorfismo se
resuelve en tiempo de ejecución del programa, es decir, A medida que se hace, en
funcionalidad de la clase a la que pertenece el objeto.
 CONCLUSIÓN

 La herencia es un mecanismo que posibilita la definición de una clase desde la definición

de otra ya que existe. La herencia posibilita compartir automáticamente procedimientos y
datos entre clases, subclases y objetos.
 La herencia está poderosamente ligada a la reutilización del código en la OOP. En otras
palabras, el código de cualquier persona de las clases podría ser usado sin más que
generar una clase derivada de ella, o bien una subclase.
 Los polimorfismos nos ayudan hacer menos códigos a momento hacer declaraciones
cuando se ocupan varias clases y los objetos d las mismas ya que con asignar un método
se puede incluir varios tipos atributos que se reflejan en cada clase que se vaya a definir
para obtener sus objetos o los arrojes para trabajar con ellos.
 BIBLIOGRAFÍA
 https://javadesdecero.es/poo/herencia-java-tipos-ejemplos/
 https://ifgeekthen.nttdata.com/es/polimorfismo-en-java-programaci%C3%B3n-orientada-
objetos#:~:text=M%C3%A9todo%20de%20Polimorfismo%20Java,implementaciones)
%20utilizados%20durante%20su%20invocaci%C3%B3n.