REPUBLICA BOLINARIA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA DEFENSA

UNIVERSIDAD NACIONAL EXPERIMENTRAL POLITECNICA
DE LA FUERZA ARMADA NAIONAL BOLIVARIANA
NUCLEO CARACAS
INGENIERÍA EN SISTEMAS
CÁTEDRA: LENGUAJE DE PROGRAMACIÓN II

INTERFACE EN JAVA

PROFESOR: BACHILLER:
DAVID CEDRES MATOS, GABRIEL C.I.: 28.434.285
MENDOZA, JESÚS C.I.: 27.862.585
ORTIZ, LISANDRO C.I.: 28.356.169
4TO SEMESTRE SECCIÓN D01

CARACAS, OCTUBRE 2022

 2

ÍNDICE

ÍNDICE ............................................................................................................................................................. 2

INTRODUCCIÓN........................................................................................................................................... 3

Interface en Java ..................................................................................................................................... 4

Herencia ..................................................................................................................................................... 6

Polimorfismo ............................................................................................................................................ 7

Ejemplos de Interfaces, Herencia y Polimorfismo ......................................................................... 8

CONCLUSIONES ........................................................................................................................................ 13

BIBLIOGRAFÍA .......................................................................................................................................... 14
 3

INTRODUCCIÓN

Una interfaz es una especie de plantilla para la construcción de clases.

Normalmente una interfaz se compone de un conjunto de declaraciones de cabeceras
de métodos (sin implementar, de forma similar a un método abstracto) que especifican
un protocolo de comportamiento para una o varias clases. Además, una clase puede
implementar una o varias interfaces: en ese caso, la clase debe proporcionar la
declaración y definición de todos los métodos de cada una de las interfaces o bien
declararse como clase abstract. Por otro lado, una interfaz puede emplearse también
para declarar constantes que luego puedan ser utilizadas por otras clases.

En esta investigación se estará trabajando con la herencia y el

polimorfismo, muchos de los lenguajes de programación hacen uso u ofrecen formas de
aplicar al mismo tiempo varios de estos paradigmas de programación. Por ejemplo, el
lenguaje de programación C aun siendo un lenguaje de programación que hace uso del
paradigma imperativo también es posible utilizar conceptos de la programación
orientada a objetos o funcionales, aunque el lenguaje en sí no ofrezca abstracciones
propias de orientación a objetos o funcionales.

El lenguaje de programación Java es orientado a objetos, aunque también en el

código de los métodos utiliza programación imperativa y con las novedades incluidas
en Java 8 con las lambdas, streams, o los records en Java 16 y el soporte en las
estructuras de datos de las colecciones permite utilizar conceptos de la programación
funcional.

En la programación orientada a objetos hay varios conceptos que definen este

paradigma de programación, la encapsulación de datos, abstracciones de los modelos
en los programas, los objetos, clases e instancias, herencia, polimorfismo y
composición.
 4

Interface en Java

Las interfaces son una forma de especificar qué debe hacer una clase sin
especificar el cómo.

Las interfaces tienen una semejanza con las clases abstractas, en el sentido que
no tiene sentido definir objetos instancia de una interfaz. Igual que las clases abstractas
clase asociada se comprometa a implementar todos los métodos en ellas definidos,
PERO en este caso la relaciones no es de herencia en plenitud, dado que no hay atributos
en la definición de una interfaz.

Las interfaces no son clases, sólo especifican requerimientos para la clase que
las implementa o, desde su uso, los servicios para la función que manipula un objeto
que se dice cumplir con la interfaz.

¿Cómo se usan las interfaces?

Debemos crear una clase que implementa la interfaz, implementar cada uno de
los métodos de la interfaz.

Podemos definir métodos que usen como parámetro objetos que implementen
la interfaz. Basta unir el nombre de la interfaz como el tipo del parámetro.

Luego, las instancias de una clase que implemente la Interfaz, pueden tomar el
lugar del argumento donde se espere alguien que implemente la interfaz.

¿Para qué se usan las interfaces de Java?

Teniendo el concepto de herencia en Java, posiblemente se pensará que esto es

igual, y de hecho es muy similar. Sin embargo, en Java no existe la herencia múltiple.

Esto quiere decir que una clase solo puede heredar de una superclase, no de
varias. Por esta razón entra en escena el concepto de interfaces.

Entonces, una clase podrá heredar métodos de varias interfaces en Java y con
este mecanismo, el lenguaje logra ofrecer una mayor abstracción a los programadores
que lo utilizan.
 5

¿Cómo se declaran las interfaces de Java?

Para declarar una interfaz en Java puedes guiarte por este esquema:

public interface nombredelainterface{

public void nombredelmetodoabstracto();

public void nombredeotrometodoabstracto();

Ahora bien, cuando llegue el momento de implementar los métodos de la

interface, se verá como sigue:

class nombredelaclase implements nombredelainterface{

public void nombredelmetodoabstracto(){

código del metodo

public void nombredelotrometodoabstracto(){

código del metodo

Finalmente, cuando vamos a crear una instancia:

class Main {

public static void main(String[] args){

nombredelaclase miclase = new nombredelaclase();

miclase.nombredelmetodoabstracto();

miclase.nombredelotrometodoabstracto();

}
 6

Resumiendo, entonces, la palabra reservada para crear interfaces es interface y

la palabra reservada necesaria para implementar los métodos abstractos de esa
interface es implements.

Cuando una clase implementa una o más interfaces, usarás la palabra reservada
implements, y vas a separar por comas el nombre de las interfaces.

Si estás enunciando los métodos abstractos de la interface, no es necesario que

utilices la palabra reservada public, ya que por defecto estos métodos son de acceso
público.

Herencia

• Es un mecanismo que permite la definición de una clase a partir de la definición

de otra ya existente.
• Permite compartir automáticamente métodos y datos entre clases, subclases y
objetos.
• Está fuertemente ligada a la reutilización del código en la POO. Esto es, el código
de cualquiera de las clases puede ser utilizado sin más que crear una clase
derivada de ella, o bien una subclase. Hay dos tipos de herencia: Herencia Simple
y Herencia Múltiple. La primera indica que se pueden definir nuevas clases
solamente a partir de una clase inicial mientras que la segunda indica que se
pueden definir nuevas clases a partir de dos o más clases iniciales.
Ventajas de la Herencia Entre las principales ventajas que ofrece la herencia en
el desarrollo de aplicaciones, están:
• Reutilización del código: En aquellos casos donde se necesita crear una clase
que, además de otros propios, deba incluir los métodos definidos en otra, la
herencia evita tener que reescribir todos esos métodos en la nueva clase.
• Mantenimiento de aplicaciones existentes: Utilizando la herencia, si tenemos
una clase con una determinada funcionalidad y tenemos la necesidad de ampliar
dicha funcionalidad, no necesitamos modificar la clase existente (la cual se
puede seguir utilizando para el tipo de programa para la que fue diseñada) sino
 7

que podemos crear una clase que herede a la primera, adquiriendo toda su
funcionalidad y añadiendo la suya propia.
Superclase y Subclases
El concepto de herencia conduce a una estructura jerárquica de clases o
estructura de árbol, lo cual significa que en la POO todas las relaciones entre clases
deben ajustarse a dicha estructura. En esta estructura jerárquica, cada clase tiene sólo
una clase padre. La clase padre de cualquier clase es conocida como su superclase. La
clase hija de una superclase es llamada una subclase.
• La palabra clave utilizada para la herencia es extends
• Una superclase puede tener cualquier número de subclases.
• Una subclase puede tener sólo una superclase.

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

Polimorfismo

Polimorfismo se refiere a la habilidad para aparecer en varias formas.

Polimorfismo en programas Java significa:

− La habilidad de una variable referencia para
cambiar su comportamiento de acuerdo con
la instancia del objeto que contiene.
− Esto permite que múltiples objetos de
diferentes subclases sea tratados como
objetos de una superclase única, mientras
que automáticamente se selecciona los
métodos apropiados a aplicar a un objeto en particular basado en la subclase a
la que pertenece
 8

Beneficios del Polimorfismo

Simplicidad
− Si se necesita escribir código que trata con una familia de subtipos, el código
puede ignorar los detalles específicos de tipo y sólo interactuar con el tipo base
de la familia.
− Aun cuando el código piense que está usando un objeto de la clase base, la clase
del objeto podría ser la clase base o cualquiera de sus subclases
Extensibilidad
• Se pueden añadir subclases posteriormente a la familia de tipos, y los objetos de
estas nuevas subclases podría trabajar con el código existente
Tres formas de polimorfismo en un programa Java
1. Overriding de método. Métodos de una subclase sobrescriben los métodos de
una superclase.
2. Overriding de método (implementación) de los métodos abstractos. Métodos de
una superclase implementa los métodos abstractos de una clase abstracta.
3. Overriding de método (implementación) a través de interface. Métodos de una
superclase implementa los métodos abstractos de la interface
Por ejemplo, dada una clase base forma, el polimorfismo permite al
programador definir diferentes métodos área para cualquier número de clases
derivadas, tales, como circulo, rectángulo, y triangulo
• El método área de circulo, rectángulo, y triangulo se implementa de manera
diferente
No importa qué forma tiene un objeto, aplicándole el método área devolverá el
resultado correcto.

Ejemplos de Interfaces, Herencia y Polimorfismo

Ejemplo de interfaz Java:

Paso 1) Copie el siguiente código en un editor.
 9

interfaz Pet {
prueba pública de vacío();
}
clase Perro implementa Pet {
prueba pública de vacío() {
System.out.println("Método de interfaz implementado");
}
public static void main(String args[]) {
Pet p = nuevo perro();
p.test();
}
}
Paso 2) Guarde, compile y ejecute el código. Observe la salida.

Ejemplo de cómo usar la herencia

//Clase para objetos de dos dimensiones
class Figura {
double base;
double altura;

void mostrarDimension(){
System.out.println("La base y altura es: "+base+" y "+altura);
}
}
//Una subclase de Figura para Triangulo
class Triangulo extends Figura {
String estilo;
double area(){
return base*altura/2;
}
void mostrarEstilo(){
 10

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

Ejemplo: polimorfismo
 11

Dada la clase padre Person y la clase hija Student, se añade otra subclase Person
que es Employee
La gráfica de la jerarquía de clases es:
Se puede crear una referencia que es del tipo
de la superclase, Person, hacia un objeto de su
subclase Student

public static main( String[] args ) {

Student studentObject = new Student();
Employee employeeObject = new Employee();
Person ref = studentObject; //referencia Person
// al objeto Student
// Llamada de getName() de la instancia de objeto Student
String name = ref.getName();
}
Supongamos ahora que hay un método getName en la superclase Person y que
este método es sobrescrito en las subclases Student y Employee
public class Student {
public String getName(){
System.out.println(“Nombre estudiante:” + name);
public class Student { public String getName(){
System.out.println(“Nombre estudiante:” + name);
System.out.println(“Nombre estudiante:” + name);
return name;
}
}
public class Employee { public String getName(){
System.out.println(“Nombre empleado:” + name);
return name;
}
}
 12

Volviendo al método main, cuando se invoca el método getName de la referencia

Person ref, el método getName del objeto Student será llamado
• Si se asigna ref a un objeto Employee, el método getName de Employee será
llamado
public static main (String[] args) {
Student studentObject = new Student();
Employee employeeObject = new Employee();
//ref apunta a un objeto Student
Person ref = studentObject;
//metodo getName() de la clase Student es invocado
public static main (String[] args) {
Student studentObject = new Student();
Employee employeeObject = new Employee();
//ref apunta a un objeto Student
Person ref = studentObject;
//metodo getName() de la clase Student es invocado
//metodo getName() de la clase Student es invocado
String temp= ref.getName();
System.out.println(temp);
//ref apunta ahora a un objeto Employee
ref = employeeObject;
//metodo getName() de la clase Employee es invocado
String temp = ref.getName();
System.out.println(temp);
}
}
 13

CONCLUSIONES

Al implementar una clase y para reutilizar el código una clase puede extender de
otra, heredando el comportamiento de la clase extendida. La relación de herencia entre
las clases es una relación de «es-un». En Java la herencia se realiza con la palabra
reservada extends.

El polimorfismo es una característica única en la programación orientada a

objetos, mientras que la encapsulación y herencia es posible conseguirla en lenguajes
no orientados a objetos de una manera razonablemente segura el polimorfismo al usar
punteros a funciones es propensa a errores. Los lenguajes orientados lo que
proporcionan es un uso sencillo y seguro del polimorfismo ocultando los detalles
internos de su implementación de sus punteros a funciones.
 14

BIBLIOGRAFÍA

• https://picodotdev.github.io/blog-bitix/2021/03/los-conceptos-de-herencia-
polimorfismo-y-composicion-de-la-programacion-orientada-a-objetos/
• https://www.arkaitzgarro.com/java/capitulo-18.html
• http://ofeliaprogra.blogspot.com/2010/10/herencia-y-polimorfismo-
modularidad-y.html
• https://ocw.unican.es/pluginfile.php/293/course/section/228/cap8-
herencia.pdf