Principi di incapsulamento in Java

Ciao! La lezione di oggi sarà dedicata all'incapsulamento e inizieremo subito con esempi :) Di fronte a te c'è una familiare macchina per la soda. Ho una domanda per te: come funziona? Prova a rispondere nel dettaglio: da dove proviene il bicchiere, come viene mantenuta la temperatura all'interno, dove viene conservato il ghiaccio, come la macchina capisce quale sciroppo aggiungere, ecc. Molto probabilmente non hai risposte a queste domande. Beh, forse non tutti usano queste macchine, non sono così popolari al giorno d'oggi. Proviamo a fare un altro esempio. Qualcosa che sai di usare molte volte al giorno. Oh, ho un'idea! Raccontaci come funziona il motore di ricerca Google . Come cerca esattamente le informazioni in base alle parole inserite? Perché questi risultati sono al top e non altri? Anche se usi Google ogni giorno, probabilmente non lo sai. Ma non è importante. Dopotutto, non è necessario che tu lo sappia. Puoi inserire query in un motore di ricerca senza pensare a come funziona esattamente. Puoi acquistare la soda da un distributore automatico senza sapere come funziona. Puoi guidare un'auto senza approfondire il funzionamento del motore a combustione interna e senza conoscere affatto la fisica, anche a livello scolastico. Tutto ciò è possibile grazie a uno dei principi fondamentali della programmazione orientata agli oggetti: l'incapsulamento . Durante la lettura di vari articoli su questo argomento, probabilmente ti sei imbattuto nel fatto che esistono due concetti comuni nella programmazione: incapsulamento e nascondimento . E con la parola “incapsulamento” gli autori intendono una cosa o l'altra (come accade). Analizzeremo entrambi i termini in modo da avere una comprensione completa. Il significato originale della parola " incapsulamento " nella programmazione è la combinazione di dati e metodi per lavorare con questi dati in un unico pacchetto ("capsula"). In Java, la classe funge da pacchetto capsula . Una classe contiene sia dati (campi di classe) che metodi per lavorare con questi dati. Questo ti sembra ovvio, ma in altri concetti di programmazione tutto funziona diversamente. Ad esempio, nella programmazione funzionale, i dati sono rigorosamente separati dalle operazioni su di essi. Nell'OOP (programmazione orientata agli oggetti), i programmi sono costituiti da classi capsule, che sono sia dati che funzioni per lavorarci. Ora parliamo di nascondersi . Com'è possibile che utilizziamo tutti i tipi di meccanismi complessi senza capire come funzionano e su cosa si basa il loro lavoro? È semplice: i loro creatori hanno fornito un'interfaccia semplice e intuitiva. Su un distributore di bibite, l'interfaccia è costituita da pulsanti su un pannello. Premendo un pulsante si seleziona il volume del bicchiere. Premendo il secondo si seleziona lo sciroppo. Il terzo è responsabile dell'aggiunta di ghiaccio. E questo è tutto ciò che devi fare. Non importa come è progettata esattamente la macchina all'interno. La cosa principale è che è progettato in modo tale che per ottenere la soda l'utente debba premere tre pulsanti . È lo stesso con un'auto. Non importa cosa sta succedendo dentro di lui. La cosa principale è che quando premi il pedale destro, l'auto va avanti e quando premi il pedale sinistro rallenta . Questa è precisamente l'essenza dell'occultamento. Tutti gli "interni" del programma sono nascosti all'utente. Per lui questa informazione è superflua e non necessaria. L'utente ha bisogno del risultato finale, non del processo interno. Consideriamo la classe come esempio Auto:

public class Auto {

   public void gas() {

       /*some complicated things are happening inside the car
       as a result of which it goes forward*/
   }

   public void brake() {

       /*some complicated things are happening inside the car
       as a result of which it slows down*/
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // How everything looks to the user

       //pressed one pedal - went
       auto.gas();

       //pressed another pedal - braked
       auto.brake();
   }
}

Questo è l'aspetto dell'implementazione nascosta in un programma Java. Tutto è come nella vita reale: all'utente viene fornita un'interfaccia (metodi). Se ha bisogno che l'auto nel programma esegua un'azione, deve solo chiamare il metodo desiderato. E ciò che accade all'interno di questi metodi sono informazioni non necessarie, l'importante è che tutto funzioni come dovrebbe. Qui abbiamo parlato di nascondere l'implementazione . Oltre a questo, Java nasconde anche i dati . Ne abbiamo parlato nella lezione su getter e setter , ma non sarebbe male ricordarvelo. 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 dall'ultima lezione qual è il problema di questa classe? In caso contrario, ricordiamolo. Il problema è che i suoi dati (campi) sono aperti a tutti e un altro programmatore può facilmente creare nel programma un gatto senza nome con un peso pari a 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 una situazione del genere, puoi monitorare da vicino se uno dei tuoi colleghi sta creando oggetti con lo stato sbagliato, ma sarebbe molto meglio escludere la possibilità stessa di creare tali “oggetti sbagliati”. Ci aiutano a nascondere i dati:

1. modificatori di accesso ( privato , protetto , pacchetto predefinito );
2. getter e setter.

Lì possiamo, ad esempio, verificare se qualcuno sta cercando di assegnare al gatto un numero negativo come età. Come abbiamo detto in precedenza, gli autori di vari articoli sull'incapsulamento intendono o l'incapsulamento (combinazione di dati e metodi), oppure l'occultamento, o entrambi. Java ha entrambi i meccanismi (questo non è necessariamente il caso in altri linguaggi OOP), quindi quest'ultima opzione è la più corretta. L'uso dell'incapsulamento ci offre diversi importanti vantaggi:

1. Monitoraggio del corretto stato dell'oggetto. Ci sono stati esempi di questo tipo sopra: grazie al setter e al modificatore private, abbiamo protetto il nostro programma dai gatti con peso 0.


2. Facilità d'uso grazie all'interfaccia. Lasciamo solo i metodi “esterni” per l'accesso degli utenti. Tutto quello che deve fare è chiamarli per ottenere il risultato e non ha bisogno di approfondire i dettagli del loro lavoro.


3. Le modifiche al codice non influiscono sugli utenti. Apportiamo tutte le modifiche all'interno dei metodi. Ciò non avrà alcun effetto sull'utente: ha scritto auto.gas() per il gas dell'auto, quindi lo scriverà. E il fatto che abbiamo cambiato qualcosa nel funzionamento del metodo gas() gli rimarrà invisibile: lui, come prima, riceverà semplicemente il risultato desiderato.