Incapsulamento in Java

CIAO! Dedicheremo la lezione di oggi all'incapsulamento in Java e inizieremo con esempi appena usciti dal cancello :) Qui hai una normale macchina per l'erogazione di bevande gassate . Ho una domanda per te: come funziona? Prova a dare una risposta dettagliata: da dove viene la soda? Come viene mantenuta la temperatura interna? Dove viene conservato il ghiaccio? Come fa la macchina a sapere quale sciroppo aggiungere? Probabilmente non hai risposte a queste domande. Ok, forse non tutti usano queste macchine. Non sono così popolari al momento. Proviamo un altro esempio. Qualcosa che usi sicuramente molte volte ogni giorno. Ah, ho un'idea! Dimmi come funziona il motore di ricerca Googlelavori. Come cerca esattamente le informazioni sulle parole che inserisci? Perché questi risultati sono al top e non altri? Anche se usi Google tutti i giorni, probabilmente non lo sai. Ma non importa. Dopotutto, non è qualcosa che devi sapere. Puoi utilizzare un motore di ricerca senza pensare esattamente a come funziona. Puoi comprare la soda da una macchina senza sapere come è costruita. Puoi guidare un'auto senza approfondire il funzionamento del motore a combustione interna e senza nemmeno conoscere la fisica del liceo. Tutto questo è possibile grazie a uno dei principi fondamentali della programmazione orientata agli oggetti: l'incapsulamento. Leggendo diversi articoli sull'argomento, devi aver incontrato due concetti di programmazione molto diffusi: l'incapsulamento e l'occultamento delle informazioni. Si dà il caso che persone diverse comprendano la parola " incapsulamento' per significare cose diverse. Decifreremo entrambi i termini in modo da avere una comprensione completa. Nella programmazione, il significato originale dil'incapsulamento combinava dati e metodi per lavorare con quei dati in un unico pacchetto ("capsula"). In Java, l'incapsulamento del pacchetto è la classe . La classe contiene sia dati (campi) che metodi per lavorare con quei dati. Questo può sembrarti ovvio, ma tutto è organizzato in modo diverso in altri paradigmi di programmazione. Ad esempio, nella programmazione funzionale, i dati sono strettamente separati dalle operazioni sui dati. Nella programmazione orientata agli oggetti (OOP), i programmi sono costituiti da capsule (classi) costituite sia da dati che da funzioni per lavorare con i dati.

Ora parliamo dell'occultamento delle informazioni

Come possiamo usare tutti i tipi di meccanismi complessi senza capire come sono costruiti o come funzionano? È semplice: i loro creatori hanno fornito interfacce semplici e convenienti. Su un distributore di bevande gassate, l'interfaccia sono i pulsanti sul pannello frontale. Un pulsante ti consente di scegliere la dimensione della tazza. Scegli lo sciroppo con un secondo pulsante. Un terzo è responsabile dell'aggiunta di ghiaccio. E questo è tutto ciò che devi fare. Non importa come appare la macchina all'interno. L'importante è che sia progettato in modo che l'utente prenda la soda premendo tre pulsanti. La stessa cosa vale per un'auto. Non importa cosa succede dentro. L'importante è che quando premi il pedale destro l'auto si muova in avanti, e quando premi il pedale sinistro l'auto rallenti. Questa è l'essenza dell'occultamento delle informazioni. Tutto di un programma' Le "interiora" di s sono nascoste all'utente. Tali informazioni sono superflue o non necessarie per l'utente. L'utente ha bisogno di un risultato finale, non di un processo interno. Per un esempio, diamo un'occhiata alClasse veicolo :

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

Questo è il modo in cui l'implementazione è nascosta in un programma Java. Proprio come nella vita reale: all'utente viene fornita un'interfaccia (metodi). In un programma, se hai bisogno di un'auto per eseguire un'azione, devi semplicemente chiamare il metodo desiderato. Ciò che accade all'interno di questi metodi è superfluo. Ciò che conta è che tutto funzioni come dovrebbe. Qui abbiamo parlato dell'occultamento dell'implementazione. Java nasconde anche i dati. Ne abbiamo parlato nella lezione su getter e setter, ma un promemoria non guasta. Ad esempio, abbiamo una classe Cat :

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

Forse ricordi da una lezione passata qual è il problema con questa classe? In caso contrario, ricordiamo. Il problema è che i suoi dati (campi) sono aperti a tutti. Un altro programmatore potrebbe facilmente creare un gatto senza nome con un peso di 0 e un'età di -1000 anni:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

In questa situazione, potresti monitorare attentamente se uno dei tuoi colleghi sta creando oggetti con stato non valido, ma sarebbe molto meglio eliminare anche la possibilità di creare questi oggetti non validi. Raggiungiamo l'occultamento dei dati con l'aiuto di:

1. modificatori di accesso ( private, protected, package default );
2. getter e setter.

Li usiamo per verificare se qualcuno sta cercando di dare al gatto un'età negativa. Come abbiamo detto in precedenza, gli autori di vari articoli sull'incapsulamento si riferiscono in realtà all'incapsulamento (combinazione di dati e metodi) o all'occultamento delle informazioni, o entrambi. Java ha entrambi i meccanismi (questo non è necessariamente il caso in altri linguaggi OOP), quindi l'ultima opzione è la più corretta.

L'incapsulamento ci offre diversi importanti vantaggi:

1. Monitoraggio del corretto stato dell'oggetto. Ne abbiamo fornito esempi sopra: grazie al setter e al modificatore privato , abbiamo protetto il nostro programma contro i gatti con un peso pari a 0.


2. Interfaccia user-friendly. Lasciamo solo i metodi esposti all'utente. L'utente deve semplicemente chiamarli per ottenere un risultato. E non c'è assolutamente bisogno di approfondire i dettagli di come funzionano.


3. Le modifiche al codice non influiscono sugli utenti. Apportiamo tutte le modifiche all'interno dei metodi. Questo non riguarda gli utenti: hanno scritto vehicle.gas() per applicare il gas, ed è quello che continueranno a fare. Il fatto che abbiamo cambiato qualcosa all'interno del metodo gas() rimane invisibile: come prima, ottengono semplicemente il risultato richiesto.