Ereditarietà
Considera un'auto e un autobus. Sono due veicoli diversi. Tuttavia, condividono alcune proprietà comuni come hanno uno sterzo, freni, ingranaggi, motore ecc.
Quindi, con il concetto di eredità, questo può essere rappresentato come segue ...
public class Vehicle {
private Driver driver;
private Seat[] seatArray; //In java and most of the Object Oriented Programming(OOP) languages, square brackets are used to denote arrays(Collections).
//You can define as many properties as you want here ...
}
Adesso una bicicletta ...
public class Bicycle extends Vehicle {
//You define properties which are unique to bicycles here ...
private Pedal pedal;
}
E una macchina ...
public class Car extends Vehicle {
private Engine engine;
private Door[] doors;
}
Questo è tutto sull'eredità . Li usiamo per classificare gli oggetti in forme Base più semplici e i loro figli, come abbiamo visto sopra.
Classi astratte
Le classi astratte sono oggetti incompleti . Per capirlo ulteriormente, consideriamo ancora una volta l'analogia del veicolo.
Un veicolo può essere guidato. Giusto? Ma veicoli diversi sono guidati in modi diversi ... Ad esempio, non puoi guidare un'auto proprio mentre guidi una bicicletta.
Quindi, come rappresentare la funzione di guida di un veicolo? È più difficile controllare che tipo di veicolo sia e guidarlo con la propria funzione; dovresti cambiare ancora e ancora la classe del conducente quando aggiungi un nuovo tipo di veicolo.
Ecco che arriva il ruolo di classi e metodi astratti. È possibile definire il metodo di azionamento come astratto per indicare che ogni figlio ereditario deve implementare questa funzione.
Quindi se modifichi la classe del veicolo ...
//......Code of Vehicle Class
abstract public void drive();
//.....Code continues
La bicicletta e l'auto devono anche specificare come guidarla. In caso contrario, il codice non verrà compilato e verrà generato un errore.
In breve ... una classe astratta è una classe parzialmente incompleta con alcune funzioni incomplete, che i figli ereditari devono specificare la propria.
Interfacce Le
interfacce sono totalmente incomplete. Non hanno proprietà. Indicano solo che i figli ereditari sono in grado di fare qualcosa ...
Supponi di avere diversi tipi di telefoni cellulari con te. Ognuno di essi ha modi diversi di svolgere funzioni diverse; Es: chiama una persona. Il produttore del telefono specifica come farlo. Qui i telefoni cellulari possono comporre un numero, ovvero è in grado di comporre il numero. Rappresentiamo questo come un'interfaccia.
public interface Dialable {
public void dial(Number n);
}
Qui il creatore del Dialable definisce come comporre un numero. Devi solo dargli un numero da comporre.
// Makers define how exactly dialable work inside.
Dialable PHONE1 = new Dialable() {
public void dial(Number n) {
//Do the phone1's own way to dial a number
}
}
Dialable PHONE2 = new Dialable() {
public void dial(Number n) {
//Do the phone2's own way to dial a number
}
}
//Suppose there is a function written by someone else, which expects a Dialable
......
public static void main(String[] args) {
Dialable myDialable = SomeLibrary.PHONE1;
SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....
Con la presente utilizzando le interfacce anziché le classi astratte, lo scrittore della funzione che utilizza un Dialable non deve preoccuparsi delle sue proprietà. Es: ha un touch-screen o una tastiera, è un telefono fisso o cellulare? Hai solo bisogno di sapere se è discutibile; eredita (o implementa) l'interfaccia Dialable.
E , soprattutto , se un giorno cambierai il Dialable con un altro
......
public static void main(String[] args) {
Dialable myDialable = SomeLibrary.PHONE2; // <-- changed from PHONE1 to PHONE2
SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....
Puoi essere sicuro che il codice funzioni ancora perfettamente perché la funzione che utilizza il dialable non dipende (e non può) dipendere da dettagli diversi da quelli specificati nell'interfaccia Dialable. Entrambi implementano un'interfaccia Dialable ed è l'unica cosa a cui interessa la funzione.
Le interfacce sono comunemente utilizzate dagli sviluppatori per garantire l'interoperabilità (utilizzare in modo intercambiabile) tra oggetti, nella misura in cui condividono una funzione comune (proprio come è possibile passare a un telefono fisso o cellulare, nella misura in cui è sufficiente comporre un numero). In breve, le interfacce sono una versione molto più semplice delle classi astratte, senza proprietà.
Inoltre, tieni presente che puoi implementare (ereditare) tutte le interfacce che desideri, ma puoi estendere (ereditare) una sola classe genitore.
Altre informazioni
Classi astratte vs interfacce
