Java - Implementing Interfaces

Question

Estoy trabajando en una tarea para mi en la clase de programación que implica la implementación de interfaces. El problema aquí es que realmente me cuesta trabajo no entender interfaces o para qué se utilizan (el profesor no fue muy bueno para explicarlo).

La tarea consistía en crear una superclase "Vehículo", y tres subclases, algo así como "Camión" o "Jeep" que tendrían cada uno un par de características propias. La clase "Vehículo" debe implementar la interfaz comparable, que creo que he descubierto (tengo el método compareTo() escrito comparando el número de puertas en los vehículos), y otra clase también debe implementar la clase "Híbrida" (no tengo idea de lo que esto significa). Luego tenemos que implementar los métodos toString(), equals(Object o) y compareTo(Object o).

Creo que tengo el compareTo() hacia abajo, pero con el equals() no tengo ni idea. Lo último que tenemos que hacer es escribir un Main para probar, esto implica hacer una matriz de objetos del Vehículo, imprimirlos, clasificarlos y luego volver a imprimirlos. También debe iterar a través de la matriz e imprimir la prima de precio para los híbridos, y utilizar el método equals(Object o) para comparar 2 vehículos.

Este es el código para mi superclase "vehículo"

package vehicle; 

abstract public class Vehicle implements Comparable { 
    private String color; 
    private int numberOfDoors; 

    // Constructor 
    /** 
    * Creates a vehicle with a color and number of doors 
    * @param aColor The color of the vehicle 
    * @param aNumberOfDoors The number of doors 
    */ 
    public Vehicle(String aColor, int aNumberOfDoors) { 
     this.color = aColor; 
     this.numberOfDoors = aNumberOfDoors; 
    } 

    // Getters 
    /** 
    * Gets the color of the vehicle 
    * @return The color of the vehicle 
    */ 
    public String getColor() {return(this.color);} 
    /** 
    * Gets the number of doors the vehicle has 
    * @return The number of doors the vehicle has 
    */ 
    public int getNumberOfDoors() {return(this.numberOfDoors);} 

    // Setters 
    /** 
    * Sets the color of the vehicle 
    * @param colorSet The color of the vehicle 
    */ 
    public void setColor(String colorSet) {this.color = colorSet;} 
    /** 
    * Sets the number of doors for the vehicle 
    * @param numberOfDoorsSet The number of doors to be set to the vehicle 
    */ 
    public void setNumberOfDoors(int numberOfDoorsSet) {this.numberOfDoors = numberOfDoorsSet;} 

    @Override 
    public int compareTo(Object o) { 
     if (o instanceof Vehicle) { 
      Vehicle v = (Vehicle)o; 
      return this.numberOfDoors - v.getNumberOfDoors(); 
     } 
     else { 
      return 0; 
     } 
    } 

    /** 
    * Returns a short string describing the vehicle 
    * @return a description of the vehicle 
    */ 
    @Override 
    public String toString() { 
     String answer = "The car's color is "+this.color 
       +". The number of doors is"+this.numberOfDoors; 
     return answer; 
    } 
} 

Y también voy a publicar uno de mis subclases

package vehicle; 

abstract public class Convertible extends Vehicle { 
    private int topSpeed; 

    // Constructor 
    /** 
    * Creates a convertible with a color, number of doors, and top speed 
    * @param aColor The color of the convertible 
    * @param aNumberOfDoors The number of doors of the convertible 
    * @param aTopSpeed The top speed of the convertible 
    */ 
    public Convertible (String aColor, int aNumberOfDoors, int aTopSpeed) { 
     super(aColor, aNumberOfDoors); 
     this.topSpeed = aTopSpeed; 
    } 

    // Getters 
    /** 
    * Gets the top speed of the convertible 
    * @return The top speed of the convertible 
    */ 
    public int getTopSpeed() {return(this.topSpeed);} 

    // Setters 
    /** 
    * Sets the top speed of the convertible 
    * @param topSpeedSet The top speed to set to the convertible 
    */ 
    public void setTopSpeed(int topSpeedSet) {this.topSpeed = topSpeedSet;} 

    /** 
    * Returns a short description of the convertible 
    * @return a short description of the convertible 
    */ 
    @Override 
    public String toString() { 
     String answer = "The car's color is "+super.getColor() 
       +", the number of doors is "+super.getNumberOfDoors() 
       +", and the top speed is "+this.topSpeed+" mph."; 
     return answer; 
    } 
} 

Definitivamente no estoy pidiendo a nadie a hacer el trabajo para mí, pero si alguien pudiera arrojar algo más de luz sobre cómo funcionan las interfaces y qué es lo que esta tarea en realidad está pidiendo, sería grandioso.

Toda la ayuda es muy apreciada

¡Gracias!

Answer 1

En lugar de hacer su ejemplo particular, voy a ver por qué las interfaces son útiles y cómo usarlas en un caso más general.

¿Qué es una interfaz?

Cuando comencé a programar, también encontré que el concepto de interfaz era confuso, así que me gusta pensar que es un "libro de reglas" estándar. Cada clase que implementa este libro de reglas tiene una lista de "reglas" que debe seguir. Por ejemplo, considere la siguiente interfaz:

interface Bounceable{ 
    public void setBounce(int bounce); 
    public int getBounce(); 
} 

Este libro de reglas anterior declara una interfaz para algo que rebota. Establece que todo lo que sea rebotable debe establecer su rebote y también obtener su rebote. Cualquier clase que implemente esta interfaz debe seguir el libro de reglas.

¿Por qué este libro de reglas sería útil?

Bueno, ¿y si quieres codificar un parque infantil, donde los niños juegan con todo tipo de cosas hinchables. Es posible realizar los siguientes tipos de cosas hinchables ..

public class FootBall implements Bounceable{ 
private int bounce; 

public void setBounce(int bounce){ 
    this.bounce = bounce; 
} 

public int getBounce(){ 
    return this.bounce; 
} 

} 

public class BaseBall implements Bounceable{ 
private int bounce; 

public void setBounce(int bounce){ 
    this.bounce = bounce; 
} 

public int getBounce(){ 
    return this.bounce; 
} 

} 

Las clases anteriores definen un tipo de pelota hinchable. Luego, harías tu clase de patio de recreo y podrías definir métodos alrededor de la interfaz abstracta de Bounceable.Por ejemplo, ¿qué pasa si un aro de baloncesto es un método en su clase? ¿y si pudiera aceptar cualquier cosa hinchable como argumento? Esto significa que puede pasar cualquier tipo de bola, siempre que implemente rebotable. Si no tiene interfaces o funcionalidades similares, podría ver qué complicado su código obtendría más pelotas que implemente.

EDIT: he incluido un pequeño ejemplo práctico ..

Un ejemplo práctico de esto sería ..

public void slamDunk(Bounceable bouncyThing){ 
    System.out.println("You scored three points!"); 
} 

ambas de las siguientes llamadas a SlamDunk son válidos ...

slamDunk(new BaseBall()); 

slamDunk(new FootBall()); 

Ahora su función slameDunk puede ganar puntos con cualquier objeto Bounceable.

Answer 2

La interfaz Comparable se describe en the docs http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html y tiene la firma:

int compareTo(T o) 
Compares this object with the specified object for order. 
Returns a negative integer, zero, or a positive integer as this object is less than, 
equal to, or greater than the specified object. 

si escribe:

public class Vehicle implements Comparable { 
//... 
} 

y luego tratar de compilarlo, obtendrá un error . La interfaz requiere que tenga que tener un método compareTo(). Tienes que escribirlo, y tiene que devolver un valor entero. Esto será positivo, negativo o cero según si el Vehículo es "mayor que", "menor que" o igual a otro Vehículo. USTED decide qué significa "mayor que", podría ser masa, edad, valor o cualquier cosa. Ese es el valor de las interfaces: dice lo que tiene que hacer, pero no cómo debe hacerlo.

Como quiera hacer esto usted mismo, le sugiero que siga cualquier tutorial sobre Comparable.

Answer 3

Como han dicho otros, una interfaz es como un contrato para una clase. Cuando una clase implementa una interfaz que está reclamando a comportarse de una manera determinada (por ejemplo, cuando su clase implementa Comparable, se dice ser comparable a otros objetos, y satisface este contrato mediante la aplicación del método de compareTo.)

Suena Al igual que su problema no es con las interfaces: ya implementó Comparable. Sin embargo, debe verificar null en su compareTo.

Preguntas sobre equals(Object o). Eso es incluso más fácil que compareTo(Object o) - necesita devolver true cuando el objeto que está comparando es el mismo que este, y false cuando no lo es. (Tenga cuidado y recuerde verificar contra null - si o es null, debe devolver falso).

Además, usted pregunta acerca de toString(), pero ya implementó toString() en su código. El único comentario es que una subclase particular 'toString() probablemente debería mencionar algo especial al respecto (por ejemplo, que es un convertible o un híbrido, etc.)

Answer 4

(En el escenario más adelante pensar en cada sustantivo como clase (algunos propiedad de tiempo) en el programa y cada verbo como método de una clase)

Usted está construyendo un robot. Abajo hizo lo siguiente en el Robot 1. 2 sensores oculares, 2 manos, 2 patas y una cabeza (altura del robot = 2 m) 2. PARA comunicarse con este robot, sacó 10 cables de la cabeza, 10 cables de la pata y 13 alambres de la mano.

Y la lógica es que si el cable de la cabeza número 1 se une al cable de la pierna número 2, el robot caminará. Si el cable número 9 en la mano se une al cable de la cabeza número 4 y el cable 1 de la cabeza se une al cable 6 de las manos, entonces ambas manos subirán ... etc. IMP Nota: el cable 3 en la cabeza nunca debe tocar el cable 5 en la pierna. Todo lo demás estallará de otra manera.

¡Qué INTERFAZ eh!

Y ahora imagine que esto tiene que darse a alguien que vea Robots por primera vez. Ahora piense en cómo se usará este robot.

---

En notas similares cuando se crea una clase que usted debe tener cuidado de cómo va a ser utilizado por otro programa. ¿Desea tener campos públicos (int y string) disponibles para otros programas o desea funciones simples que se ocupen de todas esas complejas lógicas enteras?

La interfaz proporciona una manera fácil de comunicarse entre 2 clases y al hacerlo, no tienen que preocuparse de lo que sucederá con otras cosas de mi clase.