Notazione Ungherese

Era usata in passato per il controllo dei tipi in linguaggi poco tipizzati. Veniva aggiunto al nome dell'identificatore il tipo d'appartenenza nella dichiarazione della variabile.

String stringAccount;   // irrilevante

Gfg.java   // valido
gfg.java   // invalido
public class Gfg 
{ 
  public static void main ( String[] args ) { 
    System.out.println( "GFG!" ); 
  }
}

1. package
2. classi
3. attributi-membro di classe
4. istanze
5. variabili d'istanza
6. variabili locali
7. metodi-membro di classe

✓  Identificatori di classe

→ la prima lettera della classe deve essere in maiuscolo ( è permesso minuscolo, ma scoraggiato )

→ se si usano più parole per formare il nome della classe, la prima lettera di ogni parola interna deve essere in maiuscolo. Le sottolineature sono consentite, ma non raccomandate. Sono ammessi anche numeri e simboli di valuta, anche se quest'ultimi sono scoraggiati, perché sono utilizzati come notazione per le classi interne e anonime.

1. MioJavaProgram   // sintassi valida
2. 1Program      // sintassi invalida
3. Mio1Program    // sintassi valida
4. $Program      // sintassi valida, ma scoraggiata
5. Mio$Program    // sintassi valida, ma scoraggiata ( inner class )
6. mioJavaProgram   // sintassi valida, ma scoraggiata

1. lettere
2. cifre
3. simboli di valuta
4. sottolineatura

1. MinNumero    // sintassi scoraggiata
2. alphaNum     // sintassi valida
3. ciao_mondo    // sintassi scoraggiata
4. $importo     // sintassi valida
5. ak74       // sintassi valida
6. _peso_valore   // sintassi scoraggiata
7. 67ak       // sintassi invalida
8. -importo     // sintassi invalida

✓  Come scelgo un nome per una variabile

1. Usare nomi parlanti → esplicitano il contesto del codice
   
   

   Perchè esiste ?
   Cosa fà ?
   Come viene usata ?
   

   int i;             // ambiguo
   int countAccount   // parlante
   

2. Usare distinzioni sensate:
   
   
   1. la denominazione numerica ( a1, a2, ... aN ) non solo è disinformativa, ma è del tutto non informativa
      
      

      public byte add( byte p1, byte p2 ) {...}                  // ambiguo
      public byte add( byte property, byte propertyOther ) {...} // parlante

   2. le parole di disurbo sono ridondanti
      
      

      class Product                // parlante
      class ProductData { ... }    // ambiguo
      class ProductInfo { ... }    // ambiguo

1. Evitare nomi dai significati ambigui
   
   

   Account[] listAccount;   // ambiguo ( l'identificatore non è una lista )
   Account[] accountGroup   // parlante

2. Evitare nomi con leggere differenze
   
   

   String[] pathAccountInSystem;         // ambiguo
   File[] pathAccountOutSystem;          // ambiguo
   String[] physicalPathAccountSystem;   // parlante
   File[] logicPathAccountSystem         // parlante

3. Usare nomi pronunciabili nel linguaggio naturale
   
   

   String[] phyPathAccInSys;             // ambiguo
   String[] physicalPathAccountSystem    // parlante
   

4. Usare nomi lunghi invece dei mono-lettera → sono facilmente ricercabili


5. Usare nomi mono-lettera solo nei cicli → come variabile locale di servizio


6. Aggiungere un contesto significativo → adottando l'uso di prefissi
   
   

   String state        // ambiguo
   String addrState    // parlante
   

E' un tool generatore di documentazione standard in formato HTML.

Genera documentazione API, risultato del parser su speciali tag, contenuti nei commenti del codice sorgente, a corredo di:

1. Package
2. Classi
3. Attributi-Membro di classe
4. Interfacce
5. Costruttori
6. Metodi-Membro di classe

1. @author
2. @version
3. @param
4. @return
5. @throws
6. @see
7. @since
8. @serial
9. @deprecated

/**
 * La classe genera degli identificatori casuali.
 * Ulteriori informazioni {@link org.buscati.knowledge.example}
 * 
 * @author itammb ( Italia Massimiliano Buscati )
 * @version JDK 1.15 
 */
 
 public class Example_001_JavaDoc { ... }

/**
 * Formato: anno-mese-giorno.ora.minuti.secondi.millisecondi
 */
 
public final static String PATTERN_DATETIME = "yyyy-MM-dd.hh.mm.ss.SSS";

/**
 * @return Sequenza temporale alfanumerica 
 * 
 * @throws InterruptedException
 * 
 * @see Locale
 * @see SimpleDateFormat
 * @see buscati.org
 * 
 * @since JDK 1.15
 */
 
public synchronized String timeUnique() throws InterruptedException { 
... }

✓  Requisiti di un un commento performante

1. Essere esplicativi nel codice è preferibile a qualsiasi commento
   
   

   // controlla se un dipendente ha diritto al bonus per intero
   
   if (employee.flagBonus && employee.yearsOfWork > 10 );  // ambiguo
   if (employee.isEligibleForFullBenefits());              // parlante

2. Adoperare commenti informativi:
   
   

   /**
    * Formato: anno-mese-giorno.ora.minuti.secondi.millisecondi
    */
   public final static String PATTERN_DATETIME = "yyyy-MM-dd.hh.mm.ss.SSS";
   

3. Lasciare commenti su sezioni di codice in divenire nello sviluppo

1. Adoperare commenti descrittivi
   
   

   public synchronized static int isAvailableBufferMemory() {				
     RUNTIME.gc();
   		 
     double jvmFM = Long.valueOf(RUNTIME.freeMemory()).doubleValue();
     double bufSize = jvmFM * PERC_USAGE_MEMORY;
     
     // data una %_ di utilizzo della memoria 
     // restituisce la dimensione del buffer allocabile più grande
     return Double.valueOf(bufSize).intValue();
   }

2. Usare commenti per amplificantare o chiarire l'importanza del codice
   
   

   public synchronized static long jvmFreeMemory() {	
     long jvmUM = jvmUsedMemory();
   	
     // memoria disponibile in bytes 	
     return RUNTIME.maxMemory() - jvmUM; 	
   }

Le annotazioni vengono utilizzate per fornire informazioni supplementari dentro il codice sorgente:

1. iniziano con '@'
2. non modificano la logica del codice
3. associano metadati (informazioni) a → variabili d'istanza, costruttori, metodi e classi
4. possono modificare il modo in cui un programma viene trattato dal compilatore
5. servono a fornire informazioni aggiuntive in alternativa a XML e ai marker Java

1. marcano una dichiarazione
2. non contengono parametri e non consistono in alcun dato
3. è sufficiente determinare se il marcatore è presente o assente

@Override
public String toString() 
{
  Print print = new Print();
		
  print.add("absolute path", absolute_path);
  print.add("time to log  ", getWishSCHEDULE_AT_FIXED_RATE_LOG());
				
  return print.toString( Log.class.getName() );
}

1. @Target → specifica il tipo d'elemento a cui applicare l'annotazione
   
   

   Parametro	Visibilità
   TYPE	Classe, interfaccia, tipo-enumerazione
   FIELD	Attributo-membro di classe
   METHOD	Metodo-membro di classe
   CONSTRUCTOR	Costuttore
   LOCAL_VARIABLE	Variabile locale
   ANNOTATION_TYPE	Tipo-annotazione
   PARAMETER	Parametri

   docs.oracle.com - Enum ElementType
   
   
2. @Retention → specifica a quale livello sarà disponibile l'annotazione
   
   

   Parametro	Visibilità
   SOURCE	solo nel codice sorgente
   CLASS	solo nel *.class
   RUNTIME	disponibile nel *.class e alla JVM ( in fase di run-time )

   docs.oracle.com - Enum RetentionPolicy
   
   
3. @Inherited → indica che l'annotazione può essere ereditata dalle sotto-classi. Per impostazione predefinita, le annotazioni non lo sono


4. @Documented → contrassegna l'annotazione per l'inclusione nella documentazione

docs.oracle.com - Package java.lang.annotation docs.oracle.com - Package java.lang.reflect

✓   Custom-Annotations ( personalizzate )

1. @interface viene utilizzato per dichiarare un'annotazione
2. non ha clausole throws
3. deve restituire un tipo → primitivo, String, Class, enum o array di questi tipi
4. non ha alcun parametro
5. è possibile assegnare un valore predefinito

// marker Annotation 
@interface MyAnnotation{ ... }

// dichiarazione di un annotazione 
public @interface Source {
  String autore() default "Pinco Pallino"; // valori predefiniti 
  double versione() default 0;
}

// assegnazione valori	
@Source( autore = "Massimiliano Buscati", versione = 1.1 ) 
public class TestClass { ... }

✓   Case-sensitivity

Java è un linguaggio case-sensitive → l'identificatore con nome AB, per la JVM, è diverso dal identificatore contrassegnato come Ab, aB o ab

 System.out.println("Alice");  // sintassi valida

 system.out.println("Alice");  // sintassi con errore

 public static void main(String [] args)

✓   Keywords

1. vengono utilizzate per processi interni o azioni predefinite
2. non possono essere usate come nome d'identificatore o di classe

La variabile deve essere dichiarata:

1. se d'istanza → in cima alla classe
2. se costante o enumerazione → in cima alla classe
3. se locale → vicino al codice che la manipola
   1. se di controllo → nell'istruzione del ciclo
   2. se subordinata → in cima a un blocco

1. se principale → sopra le subordinate
2. se affine ad altre → raggruppate nello stesso posto
3. se costruttore → sotto le variabili d'istanza

Quando si sviluppa un codice:

1. le variabili d'istanza sono inizialmente private ( anche final ) ma possono passare a protected
2. le costanti e le enumerazioni sono sempre static e public
3. le funzioni principali sono sempre public o protected e static ( se appartenenti alla classe )
4. le funzioni subbordinate sono sempre private e static ( se appartenenti alla classe )

public class Skeleton {

 // → costanti ed enumerazioni 
 // → variabili d'istanza
 // → metodi cotruttore
 // → funzioni principali
 // → funzioni subordinate

 // → funzioni affini principali o subordinate 
}

✓   Variabili locali

Sono definite all'interno di un blocco, di un metodo o un costruttore.

1. vengono create quando si entra nel blocco o quando il metodo viene chiamato
2. sono distrutte dopo l'uscita dal blocco o quando la chiamata ritorna dal metodo
3. lo scope di queste variabili esiste solo all'interno del blocco in cui vengono dichiarate
4. l'inizializzazione è obbligatoria

1. vengono create quando si istanzia una classe
2. vengono distrutte quando l'istanza viene distrutta
3. a differenza delle variabili locali, si può assegnare un access-specifier ( se non esplicito per default ne viene associato uno predefinito )
4. l'inizializzazione non è obbligatoria
5. hanno valore predefinito 0 o null
6. è possibile accedervi, solo creando un oggetto
   
   

   Object-Type obj = new Object-Type();

✓   Variabili statiche

Sono anche conosciute come attributi-membro di classe.

1. sono dichiarate usando la parola chiave static all'interno di una classe, al di fuori di qualsiasi costruttore o blocco di metodo
2. vengono create durante la compilazione e distrutte automaticamente al termine dell'esecuzione
3. l'inizializzazione non è obbligatoria
4. hanno valore predefinito 0 o null
5. se si accede alla variabile statica senza il nome della classe, il compilatore aggiungerà automaticamente il riferimento alla classe

1. le modifiche apportate a una variabile d'istanza, non saranno riflesse in altri oggetti, poiché ogni oggetto ha la propria copia della variabile
2. le modifiche apportate a una variabile statica, saranno riflesse in altri oggetti, poiché le variabili statiche sono comuni a tutti gli oggetti di una classe
3. possiamo accedere alle variabili d'istanza tramite riferimenti ad oggetti
4. possiamo accedere alle variabili statiche direttamente usando il nome della classe