Java - Interfacce di implementazione

Question

Sto lavorando a un compito a casa per la mia classe di programmazione che comporta l'implementazione di interfacce. Il problema qui è che in realtà non riesco a capire le interfacce o il modo in cui sono usate (il professore non era molto bravo nel spiegarlo).

L'incarico era di creare una superclasse "Veicolo", e di tre sottoclassi, qualcosa come "Camion" o "Jeep" che avrebbero ciascuno un paio di tratti propri. La classe "Vehicle" deve implementare l'interfaccia comparabile, che credo di aver capito (ho il metodo compareTo() scritto confrontando il numero di porte sui veicoli), e un'altra classe deve anche implementare la classe "Hybrid" (non ho idea cosa significhi). Dobbiamo quindi implementare i metodi toString(), equals(Object o) e compareTo(Object o).

Penso di avere il compareTo() verso il basso, ma con il equals() non ne ho idea. L'ultima cosa che dobbiamo fare è scrivere un Main da testare, ciò significa creare una serie di oggetti Vehicle, stamparli, ordinarli e poi ristamparli. Dovrebbe inoltre scorrere l'array e stampare il prezzo premium per gli ibridi e utilizzare il metodo equals(Object o) per confrontare 2 veicoli.

Ecco il codice per il mio "veicolo" superclasse

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

E mi invieranno anche uno dei miei sottoclassi

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

Sono sicuramente non chiedere a nessuno di fare il lavoro per me, ma se qualcuno riuscisse a gettare un po 'più di luce su come funzionano le interfacce e su ciò che questo compito sta davvero chiedendo sarebbe fantastico.

Tutto l'aiuto è molto apprezzato

Grazie!

Answer 1

Anziché eseguire il tuo esempio specifico, descriverò perché le interfacce sono utili e come usarle in un caso più generale.

Che cos'è un'interfaccia?

Quando ho iniziato a programmare ho trovato anche il concetto di un'interfaccia confusa, quindi mi piace considerarlo come un "libro delle regole" standard. Ogni classe che implementa questo libro delle regole ha una lista di "regole" che deve seguire. Ad esempio, si consideri la seguente interfaccia:

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

Questo sopra regola libro dichiara un'interfaccia per qualcosa che rimbalza. Afferma che tutto ciò che è rimbalzante deve rimbalzare e ottenere il rimbalzo. Qualsiasi classe che implementa questa interfaccia deve seguire il regolamento.

Perché questo manuale può essere utile?

Bene, cosa succede se si desidera programmare un parco giochi, dove i bambini giocano con ogni sorta di cose saltellanti. Si potrebbe fare i seguenti tipi di cose gonfiabili ..

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

} 

Le classi di cui sopra definire un tipo di palla rimbalzante. Dovresti quindi classificare il tuo parco giochi e definire i metodi attorno all'interfaccia Bounceable astratta.Ad esempio, cosa succede se un canestro da basket era un metodo nella tua classe? e se potesse accettare qualsiasi cosa saltellante come argomento? Ciò significherebbe che potresti passare qualsiasi tipo di palla purché rimbalzabile. Se non avessi interfacce o funzionalità simili, potresti vedere quanto il tuo codice diventerebbe disordinato, più palle implementerai.

EDIT: ho incluso un piccolo esempio pratico ..

Un esempio pratico di questo sarebbe ..

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

Entrambe le seguenti chiamate a Slamdunk sono validi ...

slamDunk(new BaseBall()); 

slamDunk(new FootBall()); 

Ora la funzione slameDunk può segnare punti con qualsiasi oggetto bounceable.

Answer 2

L'interfaccia Comparable è descritto nel the docs http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html ed ha 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. 

se si scrive:

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

e quindi provare a compilarlo, si otterrà un errore . L'interfaccia richiede che devi avere un metodo compareTo(). Devi scriverlo e deve restituire un valore intero. Questo sarà positivo, negativo o pari a zero a seconda che il Veicolo sia "maggiore di", "minore di" o uguale ad un altro Veicolo. TU decidi cosa significa "più grande di" - potrebbe essere massa, età, valore o altro. Questo è il valore delle interfacce - dice cosa devi fare, ma non come devi farlo.

Dal momento che si desidera fare da soli, suggerisco di seguire qualsiasi tutorial su Comparable.

Answer 3

Come altri hanno detto, un'interfaccia è come un contratto per una classe. Quando una classe implementa un'interfaccia sta sostenendo a comportarsi in un certo modo (per esempio quando la classe implementa Comparable, è la pretesa di essere paragonabile ad altri oggetti, e soddisfa il presente contratto implementando il metodo compareTo.)

Suona come il tuo problema non è con le interfacce - hai già implementato Comparable. Si dovrebbe verificare per null nel tuo compareTo però.

Chiedi circa equals(Object o). È ancora più semplice di compareTo(Object o) - è necessario restituire true quando l'oggetto a cui si sta confrontando è lo stesso di questo, e false quando non lo è. (Fai attenzione e ricorda di verificare con null - se o è null devi restituire false).

Inoltre, chiedi informazioni su toString(), ma hai già implementato toString() nel codice. L'unico commento è che una particolare sottoclasse 'toString() dovrebbe probabilmente menzionare qualcosa di speciale (ad esempio che è un convertibile o un ibrido ecc ...)

Answer 4

(Nello scenario di sotto pensare ad ogni sostantivo come classe (alcune proprietà di tempo) in programma e ogni verbo come metodo di una classe)

si sta costruendo un robot. Hai fatto sotto le cose su Robot 1. 2 sensori occhio, 2 mani, 2 gambe e una testa (altezza del robot = 2m) 2. Per comunicare a questo robot hai tirato fuori 10 fili fuori testa, 10 fili fuori gamba e 13 fili dalla mano.

E la logica è se il filo di testa numero 1 unisce il filo numero di legatura 2 allora il robot camminerà. Se il filo numero 9 in mano unisce il filo della testa numero 4 e il filo 1 della testa si unisce al filo 6 delle mani, allora entrambe le mani saliranno ... ecc. IMP Nota: il filo 3 sulla testa non deve mai toccare il filo 5 sulla gamba. Ogni cosa soffierà altrimenti.

Che INTERFACE huh!

E ora immagina che questo debba essere dato a qualcuno che vede i robot per la prima volta. Ora pensa a come verrà utilizzato questo robot.

---

Su note simili quando si crea un corso, è necessario fare attenzione a come verrà utilizzato da un altro programma. Vuoi avere campi pubblici (int e string) disponibili per altri programmi o vuoi funzioni semplici che si prenderanno cura di tutte quelle complesse logiche di interi.

L'interfaccia fornisce un modo semplice per comunicare tra 2 classi e, mentre lo fanno, non devono preoccuparsi di cosa accadrà ad altre cose della mia classe.