Interface I

V3.0
Octubre 2013
Ferreiras

Ferreiras interfaces JAVA 1

 topic exploration
Interfaces

From http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html

There are a number of situations in software engineering when it is important for

disparate groups of programmers to agree to a "contract" that spells out how
their software interacts. Each group should be able to write their code without
any knowledge of how the other group's code is written. Generally
speaking, interfaces are such contracts.

For example, imagine a futuristic society where computer-controlled robotic cars

transport passengers through city streets without a human operator. Automobile
manufacturers write software (Java, of course) that operates the automobile—
stop, start, accelerate, turn left, and so forth. Another industrial group, electronic
guidance instrument manufacturers, make computer systems that receive GPS
(Global Positioning System) position data and wireless transmission of traffic
conditions and use that information to drive the car.

Ferreiras interfaces JAVA 2

 topic exploration
Interfaces …

From http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html

The auto manufacturers must publish an industry-standard interface that

spells out in detail what methods can be invoked to make the car move
(any car, from any manufacturer). The guidance manufacturers can then write
software that invokes the methods described in the interface to command the
car. Neither industrial group needs to know how the other group's software is
implemented. In fact, each group considers its software highly proprietary and
reserves the right to modify it at any time, as long as it continues to adhere to
the published interface.

Ferreiras interfaces JAVA 3

 Interface JAVA
• Una interface JAVA Es un tipo sin
variables de instancia, compuesto por una
colección de constantes (opcionalmente) y
métodos abstractos y que, por lo tanto, no
puede ser instanciada.
• Define un plan para crear una clase que
la implementará, esto es, crea un protocolo
que las clases deben implementar.

Ferreiras interfaces JAVA 4

 Interface JAVA
• La notación UML es como sigue:

<<interface>>
NombreDeLaInterface
constantes ( si las hay )

firmas de los métodos

Ferreiras interfaces JAVA 5

 La sintaxis para declarar una interface
JAVA es: interface es una palabra
reservada de JAVA

public interface nombreInterface {

De manera implícita,
UNA_CONSTANTE = valor1; automáticamente, todas
El modificador los valores constantes
public NO ES ... son public static final;
OBLIGATORIO,
dependerá del T metodo1( T1 par1, T2 par2, ... );
contexto en que
se usará la
...
interface } Obsérvese que solo se usa la firma de los
métodos, esto es, no están implementados
aquí.

Ferreiras interfaces JAVA 6

  En una interface JAVA :

a) De manera implícita, automáticamente,

todas los valores constantes son public
static final; O sea, que estos modificadores
puede ser omitidos.

b) De manera implícita, automáticamente,

todos los métodos son public y abstrac.

Ferreiras interfaces JAVA 7

 La clase que implementa todos los
métodos en la interface tiene la forma:

class NombreClase implements nombreInterface {

public metodoEnIntarface() { }
Cualquier
modificador
valido en
public metodoEnInterface() { }
JAVA implements es
... palabra
} reservada de
JAVA
Otros métodos en la interface
nombreInterface y otros
métodos que la clase requiera.

Ferreiras interfaces JAVA 8

 En diagrama UML:
<<interface>>
Cuadruple
NOMBRE_DE_CONSTANTE: tipo = valor

tuplaCuadruple( String x1, int x2, double x3, char x4): void
PartoCuadruple( String nombre ) : void

Es el tipo de flecha usado y va

desde la clase hacia la interface
que esta implementa

TipoCuadruple

Ferreiras interfaces JAVA 9

/*
Interface00.java
jdk1.6.0_25

Ferreiras / JAVA / Interface

La sintaxis para definir una interface en JAVA es:

<modificador> interface <nombreDeLainterface>{

<modificador> <tipoDeRetorno> nombreDelMetodo(<opc-parametros>);
IMPORTANTE:
(1) Solo la firma del metodo ( el prototipo de la funcion en C++);
(2) Los metodos declarados en la interface son de manera implicita
publicos y abstractos
}

MAS:
(1) Para implementar una interface usar la palabra reservada implements
(2) Las clases son extends mientras que las interface son implements
(3) Una clase puede extends unicamente otras clase, mientras puede
implements cualquier cantidad de interface
*/

Ferreiras interfaces JAVA 10

 // Declarar interface

interface EjemploInterface0 {
void saludar();
}

// Implementacion del metodo en la interface

class C1 implements EjemploInterface0 {

public void saludar(){

System.out.println("\n\t=> Hola Jovenes, aun. (-_-) !\n");
}

C1() {

saludar();
}

Ferreiras interfaces JAVA 11

 // Prueba de las clases

public class Interface00 {

public static void main(String args[ ]) {
C1 x = new C1();
}
}

/*
C:\Archivos de programa\Java\jdk1.6.0_25\bin> java Interface00

=> Hola Jovenes, aun. (-_-) !

C:\Archivos de programa\Java\jdk1.6.0_25\bin>

*/

Ferreiras interfaces JAVA 12

 Otro ejemplo:
/*
Interface0.java
jdk1.6.0_22

Ferreiras / JAVA / interfaces JAVA

// Declaracion de la interface

interface Cuadruple {

// Constantes
int N = 4;

// Metodos
void tuplaCuadruple( String x1, int x2, double x3, char x4);
void PartoCuadruple( String nombre );

Ferreiras interfaces JAVA 13

// Implementacion de la interface

class TipoCuadruple implements Cuadruple {

public void tuplaCuadruple( String x1, int x2, double x3, char x4) {

System.out.println( "\n\t F( " + x1 + ", " + x2 + ", " + x3 + ", " + x4 + " )\n\t" +
" Es una Cuadrupla " );
}

public void PartoCuadruple( String nombre ) {

System.out.println( "\n\t La mujer " + nombre + "\n\t pario " + N +
" muchachos de una sola barriga \n");
}

}
La clase que implementa la
interface tiene acceso a las
constantes definidas en
dicha interface.

Ferreiras interfaces JAVA 14

 // Prueba

public class Interface0 {

public static void main(String[ ] args) {

TipoCuadruple t1 = new TipoCuadruple();

t1.PartoCuadruple( "Maria Paridora Perez Lopez ");

t1.tuplaCuadruple( "Cuenta Sanchez Pagadera", 45, 3456.78, 'G' );
}

Ferreiras interfaces JAVA 15

 /*

C:\Program Files\Java\jdk1.6.0_22\bin> java Interface0

La mujer Maria Paridora Perez Lopez

pario 4 muchachos de una sola barriga

F( Cuenta Sanchez Pagadera, 45, 3456.78, G )

Es una Cuadrupla

C:\Program Files\Java\jdk1.6.0_22\bin>

*/

Ferreiras interfaces JAVA 16

 En diagrama UML:
<<interface>>
Cuadruple
NOMBRE_DE_CONSTANTE: tipo = valor

tuplaCuadruple( String x1, int x2, double x3, char x4): void
PartoCuadruple( String nombre ) : void

Es el tipo de flecha usado y va

desde la clase hacia la interface
que esta implementa

TipoCuadruple

Ferreiras interfaces JAVA 17

 Uso interface como tipo
• Una interface es un tipo;

• Podemos declarar una variable del tipo

de la interface;

• Pero no podemos instanciar la interface.

• Lo que hacemos es asignarle un objeto

de la clase que la implementa.
Ferreiras interfaces JAVA 18
 // Interface1.java

interface Danni20 {

void desayunar();
}

class C1 implements Danni20 {

public void desayunar() {

System.out.println( "\n\t Un sanguche\n");
}
}

class C2 implements Danni20 {

public void desayunar() {
System.out.println( "\n\t Un carrito");
}

Ferreiras interfaces JAVA 19

 public class Interface1 {

public static void main( String f[ ] ) {

Danni20 d1; // d1 es una referencia a la interface

d1 = new C1();
d1.desayunar();
d1 = new C2();
d1.desayunar();
}

Ferreiras interfaces JAVA 20

 /*

C:\Archivos de programa\Java\jdk1.7.0_13\bin>javac Interface1.java

C:\Archivos de programa\Java\jdk1.7.0_13\bin>java Interface1

Un sanguche

Un carrito

C:\Archivos de programa\Java\jdk1.7.0_13\bin>

*/

Ferreiras interfaces JAVA 21

 Interface0a.java
jdk1.7.0

Ferreiras / Java / Interface / Interface como tipo

Una interface es un tipo; Podemos declar una variable del tipo

de la interface; Pero no podemos instanciar la interface. Lo que
hacemos es asignarle un objeto de la clase que la implementa.

++++++++++++++++++++

equal()

public boolean equals(Object anObject)

Compares this string to the specified object.

The result is true if and only if the argument is not null and is
a String object that represents the same sequence of
characters as this object.

Ferreiras interfaces JAVA 22

 // Declaramos la interface

interface Comparacion {
boolean esIgual( String s1 );
}

// Implementación de la interface

class Carro implements Comparacion {

private String chassiNo;

public Carro( String cha ) {

chassiNo = cha;
}

public boolean esIgual( String s ) {

return chassiNo.equals( s );
}

}
Ferreiras interfaces JAVA 23
 // Otra implementación de la interface

class Empleado implements Comparacion {

private String nombre;

public Empleado( String no ) {

nombre = no;
}

public boolean esIgual( String s ) {

return nombre.equals(s);
}
}

Ferreiras interfaces JAVA 24

 // Prueba de las clases

public class Interface0a {

public static void main( String[ ] args ) {

// Declaramos un arreglo de tipos de la Interface

Comparacion co[ ] = new Comparacion[ 3];

// Asignamos objetos de la clase que implemento la interface

co[0] = new Empleado("Fermina Andujal");

co[1] = new Carro("XY-wp Pro1234");
co[2] = new Empleado("Maria Antonieta Perez Prado");

String x = "Maria Antonieta Perez Prado"; // A ser buscado

boolean resultado = false;

Ferreiras interfaces JAVA 25

 // Prueba de las clases - continuación -

int i;
for( i = 0; i < co.length; i++ ) {
if( co[i].esIgual(x) ) {
System.out.println("\n* Encontrado !! " );
resultado = true;
break;
}
else
continue;
}

if ( resultado ) {
System.out.println("\n* La busqueda fue exitosa !! " );
}
else {
System.out.println("\n* No Encontrado !! " );
}
}
}

Ferreiras interfaces JAVA 26

 /*

C:\Archivos de programa\Java\jdk1.7.0\bin>javac Interface0a.java

C:\Archivos de programa\Java\jdk1.7.0\bin>java Interface0a

* Encontrado !!

* La busqueda fue exitosa !!

C:\Archivos de programa\Java\jdk1.7.0\bin>

*/

Ferreiras interfaces JAVA 27

 Implementación parcial de una
interface
• Mediante uso de clases abstract se
puede implementar parte de los métodos de
una interface.
• Los métodos no implementados se deben
implementar en la clase que derive de la
clase abstracta que realizó la
implementación parcial de dicha interface.

Ferreiras interfaces JAVA 28

 InterfaceParcial0.java
jdk1.7.0

Ferreiras / Java / Interface / Implementacion Parcial de Interface

Default implementations subclasses --> Es el truco. Ver en este

ejemplo.

Ferreiras interfaces JAVA 29

 interface ConvertidorMetrico {

// USA unit TO Metric unit o International System (IS)

double HP_A_KW = 0.74569987158227027;

double PSI_A_BAR = 0.06894757293168362;
double ACRE_A_HECTAREA = 0.40468564224;
double PLG_A_MM = 25.4;
double GL_A_LT = 3.785411784;
double KWHR_A_CAL = 859845.2278589854;

double hpKw( double hp);

double psiBar( double psi );
double acreHectarea ( double acre);
double plgMm(double plgs);
double glLt(double gl);
double kwhrCal( double kwhr );

Ferreiras interfaces JAVA 30

abstract class Convertidor implements ConvertidorMetrico {

public double hpKw( double hp){

return hp * HP_A_KW;
}

public double acreHectarea ( double acre) {

return acre * ACRE_A_HECTAREA;
}

} Obsérvese que solo

se implementaron
dos métodos de la
interface

Ferreiras interfaces JAVA 31

 // Implementaciones por defecto en la subclase que deriva de
// la clase abstract que implemento paracialmente la interface.
// Aqui se debe implementar todos los otros metodos de la
// interface que no fueron implementados en la clase abstract
// de la cual esta clase deriva.

class Convertidora extends Convertidor {

public double glLt(double gl){

return gl * GL_A_LT; Obsérvese que en esta clase, la
cual hereda de la clase abstract que
} implemento parte de los métodos de
la interface, se deben implementar
todos los otros métodos de dicha
public double psiBar( double psi ){
interface que se implementaron en
return psi * PSI_A_BAR; dicha clase abstract.
}

Ferreiras interfaces JAVA 32

 public double plgMm(double plg){
return plg * PLG_A_MM;
}

public double kwhrCal( double kwhr ){

return kwhr * KWHR_A_CAL;
}

public void hacerConversiones() {

Convertidora c1 = new Convertidora();
System.out.println( "\n\t * 3.00 HP = " +
c1.hpKw( 3.0 ) + " Kilovatios\n" );
}

Ferreiras interfaces JAVA 33

 public class InterfaceParcial0 {

public static void main( String[] args ) {

new Convertidora().hacerConversiones();
}
}

C:\Program Files\Java\jdk1.7.0\bin> java InterfaceParcial0

* 3.00 HP = 2.2370996147468105 Kilovatios

C:\Program Files\Java\jdk1.7.0\bin>

Ferreiras interfaces JAVA 34

 Mas de interface
 Una clase puede implementar mas de una
interface, todas separadas por coma:

class Fofi implements interface1,

interface2,
// ...,
interfaceN {
//...
}

Ferreiras interfaces JAVA 35

 Mas de interface
 Una misma interface puede ser implementada
por varias clases, proporcionando así definiciones
alternativas para los métodos.

class H implements interfaceFofi {

class F implements interfaceFofi {
//...
//...
}
}

class G implements interfaceFofi {

//... 
}

Ferreiras interfaces JAVA 36

 Una interface puede extends otra
interface:
interface Animal extends Cuadruple {

// métodos
}

La interface Animal extends la

interfaces Cuadruple

Ferreiras interfaces JAVA 37

 Una interface puede extends múltiples
interfaces:

interface OtroAnimal extends Cuadruple,

Comparable,
Orderable {
// métodos
}

La interface OtroAnimal extends las

interfaces Cuadruple, Comparable y
Orderable

Ferreiras interfaces JAVA 38

 Default Methods
For Java 8 and later, only
http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

Default methods enable you to add new functionality to the interfaces

of your libraries and ensure binary compatibility with code written for
older versions of those interfaces.

Ferreiras interfaces JAVA 39

 EJEMPLOS

Ferreiras interfaces JAVA 40

 EJERCICIOS

Ferreiras interfaces JAVA 41

 GRACIAS.

Ferreiras interfaces JAVA 42