1. Nascondo i dati: Il nucleo dell'incapsulamento sta nascondendo lo stato interno (dati) di un oggetto dall'accesso diretto per codice esterno. Ciò si ottiene attraverso modificatori di accesso (come `private`,` protetto` e `pubblico" in molte lingue).
* privato: I membri dichiarati come "privati" sono accessibili solo dall'interno della classe stessa. Nessun codice esterno, nemmeno il codice all'interno della stessa applicazione, può manipolare direttamente questi membri privati. Questo è il livello più forte di incapsulamento.
* Protetto: I membri dichiarati come "protetti" sono accessibili dall'interno della classe stessa e dalle sottoclassi (classi ereditate). Ciò consente l'accesso controllato da classi derivate pur proteggendo i dati da parti non correlate dell'applicazione.
* pubblico: I membri dichiarati come "pubblici" sono accessibili da qualsiasi parte del programma. Ciò non offre protezione e dovrebbe essere utilizzato con parsimonia. Spesso, i membri pubblici rappresentano le interfacce, per cui il codice esterno interagisce con l'oggetto senza toccare direttamente i suoi dati interni.
2. Metodi come gatekeeper: Invece di accedere direttamente ai dati privati, il codice esterno interagisce con l'oggetto attraverso i suoi metodi pubblici. Questi metodi fungono da gatekeeper, controllando il modo in cui i dati sono accessibili e modificati.
`` `Java
Dog della classe pubblica {
Nome stringa privato; // dati incapsulati
Età privata int; // dati incapsulati
Dog pubblico (nome stringa, int age) {
this.name =name;
this.age =età;
}
public String getName () {// Metodo getter
Nome di ritorno;
}
setage void public (int age) {// metodo setter
if (age> =0) {// convalida dell'input
this.age =età;
} altro {
System.out.println ("Età non valida.");
}
}
public void bark () {// metodo che opera sui dati
System.out.println (nome + "dice woof!");
}
}
Classe pubblica Main {
public static void main (string [] args) {
Cane mydog =new dog ("amico", 3);
System.out.println (mydog.getName ()); // Accesso ai dati tramite un getter
mydog.setAge (4); // Modifica dei dati tramite un setter
mydog.setAge (-1); // Esempio di convalida dell'input
mydog.bark ();
}
}
`` `
In questo esempio, `name` e` age` sono privati, prevenendo la modifica diretta. Il codice esterno può accedervi o modificarli solo tramite i metodi `getName ()` e `setage ()`. Il metodo `setage ()` fornisce anche la convalida dell'input, garantendo che l'età non sia negativa.
Vantaggi dell'incapsulamento:
* Integrità dei dati: Impedisce la corruzione accidentale o intenzionale dei dati.
* Manutente del codice: Le modifiche all'implementazione interna di una classe non influiscono sul codice esterno fintanto che l'interfaccia pubblica rimane coerente.
* Riusabilità: Le classi incapsulate sono più facili da riutilizzare in diverse parti dell'applicazione o in altri progetti.
* Sicurezza: Protegge i dati sensibili dall'accesso non autorizzato.
* Modularità: Promuove il design modulare, rendendo il codice più organizzato e più facile da capire.
In sostanza, l'incapsulamento protegge i meccanismi interni di un oggetto, migliorando l'affidabilità del codice, la manutenibilità e la sicurezza controllando l'accesso ai propri dati e metodi. È una pietra miliare di software ben strutturato e robusto.
software © www.354353.com