Java - Guida rapida

Il linguaggio di programmazione Java è stato originariamente sviluppato da Sun Microsystems, avviato da James Gosling e rilasciato nel 1995 come componente principale della piattaforma Java di Sun Microsystems (Java 1.0 [J2SE]).

L'ultima versione di Java Standard Edition è Java SE 8. Con l'avanzamento di Java e la sua diffusa popolarità, sono state create più configurazioni per adattarsi a vari tipi di piattaforme. Ad esempio: J2EE per applicazioni aziendali, J2ME per applicazioni mobili.

Le nuove versioni di J2 sono state rinominate rispettivamente come Java SE, Java EE e Java ME. Java è garantitoWrite Once, Run Anywhere.

Java è -

• Object Oriented- In Java, tutto è un oggetto. Java può essere facilmente esteso poiché si basa sul modello Object.

• Platform Independent- A differenza di molti altri linguaggi di programmazione, inclusi C e C ++, quando Java viene compilato, non viene compilato in una macchina specifica della piattaforma, piuttosto in un codice byte indipendente dalla piattaforma. Questo codice byte viene distribuito sul Web e interpretato dalla macchina virtuale (JVM) sulla piattaforma su cui viene eseguito.

• Simple- Java è progettato per essere facile da imparare. Se comprendi il concetto di base di Java OOP, sarà facile da padroneggiare.

• Secure- Con la funzione sicura di Java, consente di sviluppare sistemi privi di virus e manomissioni. Le tecniche di autenticazione si basano sulla crittografia a chiave pubblica.

• Architecture-neutral - Il compilatore Java genera un formato di file oggetto indipendente dall'architettura, che rende il codice compilato eseguibile su molti processori, con la presenza del sistema runtime Java.

• Portable- Essere neutrali dall'architettura e non avere aspetti dipendenti dall'implementazione della specifica rende Java portabile. Il compilatore in Java è scritto in ANSI C con un limite di portabilità pulito, che è un sottoinsieme POSIX.

• Robust - Java si sforza di eliminare le situazioni soggette a errori enfatizzando principalmente il controllo degli errori in fase di compilazione e il controllo del runtime.

• Multithreaded- Con la funzionalità multithread di Java è possibile scrivere programmi in grado di eseguire molte attività contemporaneamente. Questa funzionalità di progettazione consente agli sviluppatori di creare applicazioni interattive che possono essere eseguite senza problemi.

• Interpreted- Il codice byte Java viene tradotto al volo in istruzioni della macchina nativa e non viene memorizzato da nessuna parte. Il processo di sviluppo è più rapido e analitico poiché il collegamento è un processo incrementale e leggero.

• High Performance - Con l'uso di compilatori Just-In-Time, Java consente prestazioni elevate.

• Distributed - Java è progettato per l'ambiente distribuito di Internet.

• Dynamic- Java è considerato più dinamico di C o C ++ poiché è progettato per adattarsi a un ambiente in evoluzione. I programmi Java possono trasportare una grande quantità di informazioni di runtime che possono essere utilizzate per verificare e risolvere gli accessi agli oggetti in fase di runtime.

Storia di Java

James Gosling ha avviato un progetto in linguaggio Java nel giugno 1991 per l'uso in uno dei suoi numerosi progetti di set-top box. La lingua, inizialmente chiamata "Quercia" per il nome di una quercia che si trovava fuori dall'ufficio di Gosling, prese anche il nome di "Verde" e successivamente fu rinominata Java, da un elenco di parole casuali.

Sun ha rilasciato la prima implementazione pubblica come Java 1.0 nel 1995. Prometteva Write Once, Run Anywhere (WORA), fornendo tempi di esecuzione gratuiti su piattaforme popolari.

Il 13 novembre 2006, Sun ha rilasciato gran parte di Java come software gratuito e open source secondo i termini della GNU General Public License (GPL).

L'8 maggio 2007, Sun ha terminato il processo, rendendo tutto il codice core di Java libero e open-source, a parte una piccola porzione di codice di cui Sun non deteneva il copyright.

Strumenti di cui avrai bisogno

Per eseguire gli esempi discussi in questo tutorial, avrai bisogno di un computer Pentium da 200 MHz con un minimo di 64 MB di RAM (128 MB di RAM consigliati).

Avrai anche bisogno dei seguenti software:

• Sistema operativo Linux 7.1 o Windows xp / 7/8
• Java JDK 8
• Blocco note di Microsoft o qualsiasi altro editor di testo

Questo tutorial fornirà le competenze necessarie per creare GUI, networking e applicazioni Web utilizzando Java.

Cosa c'è dopo?

Il prossimo capitolo ti guiderà a come ottenere Java e la sua documentazione. Infine, fornisce istruzioni su come installare Java e preparare un ambiente per sviluppare applicazioni Java.

In questo capitolo discuteremo i diversi aspetti della configurazione di un ambiente congeniale per Java.

Configurazione dell'ambiente locale

Se sei ancora disposto a configurare il tuo ambiente per il linguaggio di programmazione Java, questa sezione ti guiderà su come scaricare e configurare Java sulla tua macchina. Di seguito sono riportati i passaggi per configurare l'ambiente.

Java SE è disponibile gratuitamente dal collegamento Scarica Java . Puoi scaricare una versione basata sul tuo sistema operativo.

Segui le istruzioni per scaricare Java ed eseguire il file .exeper installare Java sulla tua macchina. Una volta installato Java sulla macchina, sarà necessario impostare le variabili di ambiente in modo che puntino alle directory di installazione corrette -

Configurazione del percorso per Windows

Supponendo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

• Fare clic con il pulsante destro del mouse su "Risorse del computer" e selezionare "Proprietà".

• Fare clic sul pulsante "Variabili d'ambiente" nella scheda "Avanzate".

• Ora, modifica la variabile "Path" in modo che contenga anche il percorso dell'eseguibile Java. Ad esempio, se il percorso è attualmente impostato su "C: \ WINDOWS \ SYSTEM32", modificare il percorso in "C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin".

Configurazione del percorso per Linux, UNIX, Solaris, FreeBSD

La variabile d'ambiente PATH dovrebbe essere impostata in modo che punti a dove sono stati installati i binari Java. Fare riferimento alla documentazione della shell, se si hanno problemi a farlo.

Esempio, se usi bash come shell, aggiungi la seguente riga alla fine di '.bashrc: export PATH = / path / to / java: $ PATH'

Editor Java popolari

Per scrivere i tuoi programmi Java, avrai bisogno di un editor di testo. Sul mercato sono disponibili IDE ancora più sofisticati. Ma per ora, puoi considerare uno dei seguenti:

• Notepad - Su macchina Windows, puoi utilizzare qualsiasi semplice editor di testo come Blocco note (consigliato per questo tutorial), TextPad.

• Netbeans - Un IDE Java che è open-source e gratuito che può essere scaricato da https://www.netbeans.org/index.html.

• Eclipse - Un IDE Java sviluppato dalla comunità open source di eclipse e può essere scaricato da https://www.eclipse.org/.

Cosa c'è dopo?

Il prossimo capitolo ti insegnerà come scrivere ed eseguire il tuo primo programma Java e alcune delle importanti sintassi di base in Java necessarie per lo sviluppo di applicazioni.

Quando consideriamo un programma Java, può essere definito come una raccolta di oggetti che comunicano invocando i reciproci metodi. Vediamo ora brevemente cosa significano classi, oggetti, metodi e variabili di istanza.

• Object- Gli oggetti hanno stati e comportamenti. Esempio: un cane ha degli stati: colore, nome, razza e comportamenti come scodinzolare, abbaiare, mangiare. Un oggetto è un'istanza di una classe.

• Class - Una classe può essere definita come un modello / progetto che descrive il comportamento / stato supportato dall'oggetto del suo tipo.

• Methods- Un metodo è fondamentalmente un comportamento. Una classe può contenere molti metodi. È nei metodi in cui vengono scritte le logiche, i dati vengono manipolati e tutte le azioni vengono eseguite.

• Instance Variables- Ogni oggetto ha il suo insieme univoco di variabili di istanza. Lo stato di un oggetto viene creato dai valori assegnati a queste variabili di istanza.

Primo programma Java

Esaminiamo un semplice codice che stamperà le parole Hello World.

Esempio

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

Diamo un'occhiata a come salvare il file, compilare ed eseguire il programma. Si prega di seguire i passaggi successivi:

• Apri il blocco note e aggiungi il codice come sopra.

• Salva il file come: MyFirstJavaProgram.java.

• Apri una finestra del prompt dei comandi e vai alla directory in cui hai salvato la classe. Supponiamo che sia C: \.

• Digita "javac MyFirstJavaProgram.java" e premi Invio per compilare il codice. Se non ci sono errori nel codice, il prompt dei comandi ti porterà alla riga successiva (presupposto: la variabile del percorso è impostata).

• Ora, digita "java MyFirstJavaProgram" per eseguire il programma.

• Sarai in grado di vedere "Hello World" stampato sulla finestra.

Produzione

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

Sintassi di base

Riguardo ai programmi Java, è molto importante tenere a mente i seguenti punti.

• Case Sensitivity - Java distingue tra maiuscole e minuscole, il che significa identificatore Hello e hello avrebbe un significato diverso in Java.

• Class Names- Per tutti i nomi di classe la prima lettera deve essere in maiuscolo. Se vengono utilizzate più parole per formare un nome della classe, la prima lettera di ciascuna parola interna deve essere in maiuscolo.

  Example: class MyFirstJavaClass

• Method Names- Tutti i nomi dei metodi dovrebbero iniziare con una lettera minuscola. Se vengono utilizzate più parole per formare il nome del metodo, la prima lettera di ciascuna parola interna deve essere in maiuscolo.

  Example: public void myMethodName ()

• Program File Name - Il nome del file di programma deve corrispondere esattamente al nome della classe.

  Quando si salva il file, è necessario salvarlo utilizzando il nome della classe (ricorda che Java fa distinzione tra maiuscole e minuscole) e aggiungere '.java' alla fine del nome (se il nome del file e il nome della classe non corrispondono, il programma non verrà compilato ).

  Example:Supponiamo che "MyFirstJavaProgram" sia il nome della classe. Quindi il file dovrebbe essere salvato come 'MyFirstJavaProgram.java'

• public static void main(String args[]) - L'elaborazione del programma Java inizia dal metodo main (), che è una parte obbligatoria di ogni programma Java.

Identificatori Java

Tutti i componenti Java richiedono nomi. Vengono chiamati i nomi utilizzati per classi, variabili e metodiidentifiers.

In Java, ci sono diversi punti da ricordare sugli identificatori. Sono i seguenti:

• Tutti gli identificatori devono iniziare con una lettera (dalla A alla Z o dalla a alla z), un carattere di valuta ($) o un trattino basso (_).

• Dopo il primo carattere, gli identificatori possono avere qualsiasi combinazione di caratteri.

• Una parola chiave non può essere utilizzata come identificatore.

• Ancora più importante, gli identificatori fanno distinzione tra maiuscole e minuscole.

• Esempi di identificatori legali: età, $ stipendio, _value, __1_value.

• Esempi di identificatori illegali: 123abc, -salary.

Modificatori Java

Come altri linguaggi, è possibile modificare classi, metodi, ecc., Utilizzando i modificatori. Esistono due categorie di modificatori:

• Access Modifiers - predefinito, pubblico, protetto, privato

• Non-access Modifiers - finale, astratto, rigoroso

Esamineremo maggiori dettagli sui modificatori nella prossima sezione.

Variabili Java

Di seguito sono riportati i tipi di variabili in Java:

• Variabili locali
• Variabili di classe (variabili statiche)
• Variabili di istanza (variabili non statiche)

Array Java

Gli array sono oggetti che memorizzano più variabili dello stesso tipo. Tuttavia, un array stesso è un oggetto nell'heap. Nei prossimi capitoli esamineremo come dichiarare, costruire e inizializzare.

Java Enums

Gli enum sono stati introdotti in Java 5.0. Le enumerazioni limitano una variabile in modo che abbia solo uno dei pochi valori predefiniti. I valori in questo elenco enumerato sono chiamati enumerazioni.

Con l'uso delle enumerazioni è possibile ridurre il numero di bug nel codice.

Ad esempio, se consideriamo una domanda per un negozio di succhi freschi, sarebbe possibile limitare le dimensioni del bicchiere a piccolo, medio e grande. Ciò garantirebbe che non consentirebbe a nessuno di ordinare dimensioni diverse da piccola, media o grande.

Esempio

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

L'esempio sopra produrrà il seguente risultato:

Produzione

Size: MEDIUM

Note- Gli enum possono essere dichiarati come propri o all'interno di una classe. Anche metodi, variabili, costruttori possono essere definiti all'interno di enumerazioni.

Parole chiave Java

Il seguente elenco mostra le parole riservate in Java. Queste parole riservate non possono essere utilizzate come costanti, variabili o altri nomi di identificatori.

astratto	asserire	booleano	rompere
byte	Astuccio	catturare	char
classe	const	Continua	predefinito
fare	Doppio	altro	enum
si estende	finale	finalmente	galleggiante
per	vai a	Se	attrezzi
importare	istanza di	int	interfaccia
lungo	nativo	nuovo	pacchetto
privato	protetto	pubblico	ritorno
corto	statico	strictfp	super
interruttore	sincronizzato	Questo	gettare
lanci	transitorio	provare	vuoto
volatile	mentre

Commenti in Java

Java supporta commenti su una riga e su più righe molto simili a C e C ++. Tutti i caratteri disponibili all'interno di qualsiasi commento vengono ignorati dal compilatore Java.

Esempio

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

Produzione

Hello World

Utilizzo di righe vuote

Una riga contenente solo uno spazio bianco, possibilmente con un commento, è nota come riga vuota e Java la ignora completamente.

Eredità

In Java, le classi possono essere derivate dalle classi. Fondamentalmente, se devi creare una nuova classe e qui è già una classe che ha parte del codice richiesto, allora è possibile derivare la tua nuova classe dal codice già esistente.

Questo concetto consente di riutilizzare i campi e i metodi della classe esistente senza dover riscrivere il codice in una nuova classe. In questo scenario, la classe esistente è chiamatasuperclass e la classe derivata è chiamata subclass.

Interfacce

In linguaggio Java, un'interfaccia può essere definita come un contratto tra oggetti su come comunicare tra loro. Le interfacce svolgono un ruolo fondamentale quando si tratta del concetto di eredità.

Un'interfaccia definisce i metodi, una classe derivante (sottoclasse) dovrebbe usare. Ma l'implementazione dei metodi dipende totalmente dalla sottoclasse.

Cosa c'è dopo?

La sezione successiva spiega gli oggetti e le classi nella programmazione Java. Alla fine della sessione, sarai in grado di ottenere un'immagine chiara di cosa sono gli oggetti e cosa sono le classi in Java.

Java è un linguaggio orientato agli oggetti. Essendo un linguaggio dotato della funzionalità Object-Oriented, Java supporta i seguenti concetti fondamentali:

• Polymorphism
• Inheritance
• Encapsulation
• Abstraction
• Classes
• Objects
• Instance
• Method
• Passaggio del messaggio

In questo capitolo esamineremo i concetti: classi e oggetti.

• Object- Gli oggetti hanno stati e comportamenti. Esempio: un cane ha degli stati - colore, nome, razza e comportamenti - scodinzolare, abbaiare, mangiare. Un oggetto è un'istanza di una classe.

• Class - Una classe può essere definita come un modello / progetto che descrive il comportamento / stato che l'oggetto del suo tipo supporta.

Oggetti in Java

Vediamo ora in profondità cosa sono gli oggetti. Se consideriamo il mondo reale, possiamo trovare molti oggetti intorno a noi, automobili, cani, esseri umani, ecc. Tutti questi oggetti hanno uno stato e un comportamento.

Se consideriamo un cane, il suo stato è: nome, razza, colore e il comportamento è: abbaiare, scodinzolare, correre.

Se si confronta l'oggetto software con un oggetto del mondo reale, hanno caratteristiche molto simili.

Gli oggetti software hanno anche uno stato e un comportamento. Lo stato di un oggetto software viene memorizzato nei campi e il comportamento viene mostrato tramite metodi.

Quindi, nello sviluppo del software, i metodi operano sullo stato interno di un oggetto e la comunicazione da oggetto a oggetto avviene tramite metodi.

Classi in Java

Una classe è un progetto da cui vengono creati i singoli oggetti.

Di seguito è riportato un esempio di una classe.

Esempio

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Una classe può contenere uno dei seguenti tipi di variabili.

• Local variables- Le variabili definite all'interno di metodi, costruttori o blocchi sono chiamate variabili locali. La variabile verrà dichiarata e inizializzata all'interno del metodo e la variabile verrà distrutta al termine del metodo.

• Instance variables- Le variabili di istanza sono variabili all'interno di una classe ma al di fuori di qualsiasi metodo. Queste variabili vengono inizializzate quando viene creata un'istanza della classe. È possibile accedere alle variabili di istanza dall'interno di qualsiasi metodo, costruttore o blocco di quella particolare classe.

• Class variables - Le variabili di classe sono variabili dichiarate all'interno di una classe, al di fuori di qualsiasi metodo, con la parola chiave statica.

Una classe può avere un numero qualsiasi di metodi per accedere al valore di vari tipi di metodi. Nell'esempio sopra, barking (), hungry () e sleeping () sono metodi.

Di seguito sono riportati alcuni degli argomenti importanti che devono essere discussi quando si esaminano le classi del linguaggio Java.

Costruttori

Quando si discute delle classi, uno degli argomenti secondari più importanti sarebbero i costruttori. Ogni classe ha un costruttore. Se non scriviamo esplicitamente un costruttore per una classe, il compilatore Java costruisce un costruttore predefinito per quella classe.

Ogni volta che viene creato un nuovo oggetto, verrà richiamato almeno un costruttore. La regola principale dei costruttori è che dovrebbero avere lo stesso nome della classe. Una classe può avere più di un costruttore.

Di seguito è riportato un esempio di un costruttore:

Esempio

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

Java supporta anche le classi Singleton in cui potresti creare solo un'istanza di una classe.

Note- Abbiamo due diversi tipi di costruttori. Discuteremo i costruttori in dettaglio nei capitoli successivi.

Creazione di un oggetto

Come accennato in precedenza, una classe fornisce i progetti per gli oggetti. Quindi, fondamentalmente, un oggetto viene creato da una classe. In Java, la nuova parola chiave viene utilizzata per creare nuovi oggetti.

Ci sono tre passaggi quando si crea un oggetto da una classe:

• Declaration - Una dichiarazione di variabile con un nome di variabile con un tipo di oggetto.

• Instantiation - La parola chiave "new" viene utilizzata per creare l'oggetto.

• Initialization- La parola chiave "new" è seguita da una chiamata a un costruttore. Questa chiamata inizializza il nuovo oggetto.

Di seguito è riportato un esempio di creazione di un oggetto:

Esempio

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Se compiliamo ed eseguiamo il programma sopra, produrrà il seguente risultato:

Produzione

Passed Name is :tommy

Accesso a variabili e metodi di istanza

È possibile accedere alle variabili e ai metodi di istanza tramite oggetti creati. Per accedere a una variabile di istanza, di seguito è riportato il percorso completo:

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Esempio

Questo esempio spiega come accedere alle variabili di istanza e ai metodi di una classe.

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Se compiliamo ed eseguiamo il programma sopra, produrrà il seguente risultato:

Produzione

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Regole di dichiarazione del file di origine

Come ultima parte di questa sezione, esaminiamo ora le regole di dichiarazione del file sorgente. Queste regole sono essenziali quando si dichiarano classi, istruzioni di importazione e istruzioni di pacchetto in un file sorgente.

• Può esserci una sola classe pubblica per file di origine.

• Un file di origine può avere più classi non pubbliche.

• Il nome della classe pubblica dovrebbe essere anche il nome del file sorgente che dovrebbe essere aggiunto da .javaalla fine. Ad esempio: il nome della classe è public class Employee {}, quindi il file di origine dovrebbe essere Employee.java.

• Se la classe è definita all'interno di un pacchetto, l'istruzione del pacchetto dovrebbe essere la prima istruzione nel file sorgente.

• Se sono presenti istruzioni di importazione, devono essere scritte tra l'istruzione del pacchetto e la dichiarazione della classe. Se non sono presenti istruzioni del pacchetto, l'istruzione import dovrebbe essere la prima riga del file di origine.

• Le istruzioni di importazione e di pacchetto implicheranno tutte le classi presenti nel file sorgente. Non è possibile dichiarare istruzioni di importazione e / o pacchetto differenti a classi differenti nel file sorgente.

Le classi hanno diversi livelli di accesso e ci sono diversi tipi di classi; classi astratte, classi finali, ecc. Spiegheremo tutto questo nel capitolo sui modificatori di accesso.

Oltre ai tipi di classi sopra menzionati, Java ha anche alcune classi speciali chiamate classi interne e classi anonime.

Pacchetto Java

In parole semplici, è un modo per classificare le classi e le interfacce. Quando si sviluppano applicazioni in Java, verranno scritte centinaia di classi e interfacce, pertanto classificare queste classi è un must e semplifica notevolmente la vita.

Dichiarazioni di importazione

In Java, se viene fornito un nome completo, che include il pacchetto e il nome della classe, il compilatore può facilmente individuare il codice sorgente o le classi. L'istruzione Import è un modo per fornire al compilatore la posizione corretta per trovare quella particolare classe.

Ad esempio, la riga seguente chiederebbe al compilatore di caricare tutte le classi disponibili nella directory installazione_java / java / io -

import java.io.*;

Un semplice caso di studio

Per il nostro caso di studio, creeremo due classi. Sono Employee e EmployeeTest.

Per prima cosa apri il blocco note e aggiungi il codice seguente. Ricorda che questa è la classe Employee e la classe è una classe pubblica. Ora salva questo file sorgente con il nome Employee.java.

La classe Employee ha quattro variabili di istanza: nome, età, designazione e stipendio. La classe ha un costruttore definito in modo esplicito, che accetta un parametro.

Esempio

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Come accennato in precedenza in questo tutorial, l'elaborazione inizia dal metodo principale. Pertanto, per poter eseguire questa classe Employee, dovrebbe esserci un metodo principale e gli oggetti dovrebbero essere creati. Creeremo una classe separata per questi compiti.

Di seguito è riportata la classe EmployeeTest , che crea due istanze della classe Employee e richiama i metodi per ogni oggetto per assegnare valori per ogni variabile.

Salvare il codice seguente nel file EmployeeTest.java.

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Ora, compila entrambe le classi e quindi esegui EmployeeTest per vedere il risultato come segue:

Produzione

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

Cosa c'è dopo?

Nella prossima sessione, discuteremo i tipi di dati di base in Java e come possono essere utilizzati durante lo sviluppo di applicazioni Java.

Un costruttore inizializza un oggetto quando viene creato. Ha lo stesso nome della sua classe ed è sintatticamente simile a un metodo. Tuttavia, i costruttori non hanno un tipo restituito esplicito.

In genere, si utilizzerà un costruttore per fornire valori iniziali alle variabili di istanza definite dalla classe o per eseguire qualsiasi altra procedura di avvio richiesta per creare un oggetto completamente formato.

Tutte le classi hanno costruttori, che tu ne definisca uno o meno, perché Java fornisce automaticamente un costruttore predefinito che inizializza tutte le variabili membro a zero. Tuttavia, una volta definito il proprio costruttore, il costruttore predefinito non viene più utilizzato.

Sintassi

Di seguito è riportata la sintassi di un costruttore:

class ClassName {
   ClassName() {
   }
}

Java consente due tipi di costruttori:

• Nessun argomento costruttori
• Costruttori parametrizzati

Nessun argomento costruttori

Poiché il nome specifica che i costruttori senza argomenti di Java non accettano alcun parametro, utilizzando questi costruttori le variabili di istanza di un metodo verranno inizializzate con valori fissi per tutti gli oggetti.

Esempio

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

Chiameresti il ​​costruttore per inizializzare gli oggetti come segue

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

Ciò produrrebbe il seguente risultato

100 100

Costruttori parametrizzati

Molto spesso, avrai bisogno di un costruttore che accetti uno o più parametri. I parametri vengono aggiunti a un costruttore nello stesso modo in cui vengono aggiunti a un metodo, è sufficiente dichiararli tra parentesi dopo il nome del costruttore.

Esempio

Ecco un semplice esempio che utilizza un costruttore:

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

Chiameresti il ​​costruttore per inizializzare gli oggetti come segue:

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

Ciò produrrebbe il seguente risultato:

10 20

Le variabili non sono altro che posizioni di memoria riservate per memorizzare i valori. Ciò significa che quando crei una variabile riservi dello spazio in memoria.

In base al tipo di dati di una variabile, il sistema operativo alloca la memoria e decide cosa può essere archiviato nella memoria riservata. Pertanto, assegnando diversi tipi di dati alle variabili, è possibile memorizzare numeri interi, decimali o caratteri in queste variabili.

Ci sono due tipi di dati disponibili in Java:

• Tipi di dati primitivi
• Tipi di dati di riferimento / oggetto

Tipi di dati primitivi

Esistono otto tipi di dati primitivi supportati da Java. I tipi di dati primitivi sono predefiniti dalla lingua e denominati da una parola chiave. Esaminiamo ora in dettaglio gli otto tipi di dati primitivi.

byte

• Il tipo di dati byte è un intero con complemento a due con segno a 8 bit

• Il valore minimo è -128 (-2 ^ 7)

• Il valore massimo è 127 (incluso) (2 ^ 7-1)

• Il valore predefinito è 0

• Il tipo di dati byte viene utilizzato per risparmiare spazio in array di grandi dimensioni, principalmente al posto degli interi, poiché un byte è quattro volte più piccolo di un numero intero.

• Esempio: byte a = 100, byte b = -50

corto

• Il tipo di dati breve è un intero con complemento a due con segno a 16 bit

• Il valore minimo è -32.768 (-2 ^ 15)

• Il valore massimo è 32.767 (inclusi) (2 ^ 15-1)

• Il tipo di dati breve può anche essere utilizzato per salvare la memoria come tipo di dati byte. Uno short è 2 volte più piccolo di un intero

• Il valore predefinito è 0.

• Esempio: breve s = 10000, breve r = -20000

int

• Il tipo di dati Int è un intero con complemento a due con segno a 32 bit.

• Il valore minimo è - 2.147.483.648 (-2 ^ 31)

• Il valore massimo è 2.147.483.647 (incluso) (2 ^ 31-1)

• Integer viene generalmente utilizzato come tipo di dati predefinito per i valori integrali a meno che non vi siano problemi di memoria.

• Il valore predefinito è 0

• Esempio: int a = 100000, int b = -200000

lungo

• Il tipo di dati lungo è un intero con complemento a due con segno a 64 bit
• Il valore minimo è -9.223.372.036.854.775.808 (-2 ^ 63)
• Il valore massimo è 9.223.372.036.854.775.807 (inclusi) (2 ^ 63-1)
• Questo tipo viene utilizzato quando è necessario un intervallo più ampio di int
• Il valore predefinito è 0L
• Esempio: lungo a = 100000L, lungo b = -200000L

galleggiante

• Il tipo di dati Float è una virgola mobile IEEE 754 a 32 bit a precisione singola

• Float viene utilizzato principalmente per risparmiare memoria in grandi array di numeri in virgola mobile

• Il valore predefinito è 0.0f

• Il tipo di dati Float non viene mai utilizzato per valori precisi come la valuta

• Esempio: float f1 = 234.5f

Doppio

• Il tipo di dati double è una virgola mobile IEEE 754 a doppia precisione a 64 bit

• Questo tipo di dati viene generalmente utilizzato come tipo di dati predefinito per i valori decimali, generalmente la scelta predefinita

• Il doppio tipo di dati non deve mai essere utilizzato per valori precisi come la valuta

• Il valore predefinito è 0,0 d

• Esempio: double d1 = 123,4

booleano

• Il tipo di dati booleano rappresenta un bit di informazione
• Ci sono solo due possibili valori: vero e falso
• Questo tipo di dati viene utilizzato per flag semplici che tengono traccia delle condizioni vere / false
• Il valore predefinito è false
• Esempio: booleano uno = vero

char

• il tipo di dati char è un singolo carattere Unicode a 16 bit
• Il valore minimo è "\ u0000" (o 0)
• Il valore massimo è "\ uffff" (o 65.535 inclusi)
• Il tipo di dati Char viene utilizzato per memorizzare qualsiasi carattere
• Esempio: char letterA = 'A'

Tipi di dati di riferimento

• Le variabili di riferimento vengono create utilizzando costruttori definiti delle classi. Sono usati per accedere agli oggetti. Queste variabili sono dichiarate di un tipo specifico che non può essere modificato. Ad esempio, dipendente, cucciolo, ecc.

• Gli oggetti di classe e vari tipi di variabili di matrice rientrano nel tipo di dati di riferimento.

• Il valore predefinito di qualsiasi variabile di riferimento è null.

• Una variabile di riferimento può essere utilizzata per fare riferimento a qualsiasi oggetto del tipo dichiarato o qualsiasi tipo compatibile.

• Esempio: Animale animale = nuovo Animale ("giraffa");

Letterali Java

Un letterale è una rappresentazione del codice sorgente di un valore fisso. Sono rappresentati direttamente nel codice senza alcun calcolo.

I valori letterali possono essere assegnati a qualsiasi variabile di tipo primitivo. Ad esempio:

byte a = 68;
char a = 'A';

byte, int, long e short possono essere espressi anche in sistemi numerici decimale (base 10), esadecimale (base 16) o ottale (base 8).

Il prefisso 0 viene utilizzato per indicare ottale e il prefisso 0x indica esadecimale quando si utilizzano questi sistemi numerici per i letterali. Ad esempio:

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

I letterali stringa in Java vengono specificati come nella maggior parte delle altre lingue racchiudendo una sequenza di caratteri tra una coppia di virgolette doppie. Esempi di stringhe letterali sono:

Esempio

"Hello World"
"two\nlines"
"\"This is in quotes\""

I tipi stringa e char di letterali possono contenere qualsiasi carattere Unicode. Ad esempio:

char a = '\u0001';
String a = "\u0001";

Il linguaggio Java supporta anche alcune sequenze di escape speciali per String e char literals. Sono -

Notazione	Carattere rappresentato
\ n	Nuova riga (0x0a)
\ r	Ritorno a capo (0x0d)
\ f	Formfeed (0x0c)
\ b	Backspace (0x08)
\S	Spazio (0x20)
\ t	tab
\ "	Virgolette doppie
\ '	Virgoletta singola
\\	barra rovesciata
\ ddd	Carattere ottale (ddd)
\ uxxxx	Carattere UNICODE esadecimale (xxxx)

Cosa c'è dopo?

Questo capitolo ha spiegato i vari tipi di dati. L'argomento successivo spiega diversi tipi di variabili e il loro utilizzo. Questo ti darà una buona comprensione di come possono essere utilizzati nelle classi Java, nelle interfacce, ecc.

Una variabile ci fornisce una memoria con nome che i nostri programmi possono manipolare. Ogni variabile in Java ha un tipo specifico, che determina la dimensione e il layout della memoria della variabile; l'intervallo di valori che possono essere memorizzati all'interno di quella memoria; e l'insieme di operazioni che possono essere applicate alla variabile.

È necessario dichiarare tutte le variabili prima che possano essere utilizzate. Di seguito è riportata la forma base di una dichiarazione di variabile:

data type variable [ = value][, variable [ = value] ...] ;

Qui il tipo di dati è uno dei tipi di dati di Java e la variabile è il nome della variabile. Per dichiarare più di una variabile del tipo specificato, puoi utilizzare un elenco separato da virgole.

Di seguito sono riportati esempi validi di dichiarazione e inizializzazione di variabili in Java:

Esempio

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

Questo capitolo spiegherà i vari tipi di variabili disponibili in Java Language. Esistono tre tipi di variabili in Java:

• Variabili locali
• Variabili di istanza
• Variabili di classe / statiche

Variabili locali

• Le variabili locali vengono dichiarate in metodi, costruttori o blocchi.

• Le variabili locali vengono create quando si immette il metodo, il costruttore o il blocco e la variabile verrà distrutta una volta che esce dal metodo, dal costruttore o dal blocco.

• I modificatori di accesso non possono essere utilizzati per le variabili locali.

• Le variabili locali sono visibili solo all'interno del metodo, costruttore o blocco dichiarato.

• Le variabili locali vengono implementate internamente a livello di stack.

• Non esiste un valore predefinito per le variabili locali, quindi è necessario dichiarare le variabili locali e assegnare un valore iniziale prima del primo utilizzo.

Esempio

Qui l' età è una variabile locale. Questo è definito all'interno del metodo pupAge () e il suo ambito è limitato solo a questo metodo.

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Questo produrrà il seguente risultato:

Produzione

Puppy age is: 7

Esempio

L'esempio seguente usa age senza inizializzarlo, quindi darebbe un errore al momento della compilazione.

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Questo produrrà il seguente errore durante la compilazione:

Produzione

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Variabili di istanza

• Le variabili di istanza sono dichiarate in una classe, ma al di fuori di un metodo, un costruttore o qualsiasi blocco.

• Quando uno spazio viene allocato per un oggetto nell'heap, viene creato uno slot per ogni valore della variabile di istanza.

• Le variabili di istanza vengono create quando un oggetto viene creato con l'uso della parola chiave "nuovo" e distrutte quando l'oggetto viene distrutto.

• Le variabili di istanza contengono valori che devono essere referenziati da più di un metodo, costruttore o blocco, o parti essenziali dello stato di un oggetto che devono essere presenti in tutta la classe.

• Le variabili di istanza possono essere dichiarate a livello di classe prima o dopo l'uso.

• Possono essere forniti modificatori di accesso per variabili di istanza.

• Le variabili di istanza sono visibili per tutti i metodi, costruttori e blocchi nella classe. Normalmente, si consiglia di rendere private queste variabili (livello di accesso). Tuttavia, la visibilità per le sottoclassi può essere data per queste variabili con l'uso di modificatori di accesso.

• Le variabili di istanza hanno valori predefiniti. Per i numeri, il valore predefinito è 0, per i booleani è falso e per i riferimenti a oggetti è nullo. I valori possono essere assegnati durante la dichiarazione o all'interno del costruttore.

• È possibile accedere alle variabili di istanza direttamente chiamando il nome della variabile all'interno della classe. Tuttavia, all'interno dei metodi statici (quando viene fornita l'accessibilità alle variabili di istanza), dovrebbero essere chiamate utilizzando il nome completo. ObjectReference.VariableName .

Esempio

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

Questo produrrà il seguente risultato:

Produzione

name  : Ransika
salary :1000.0

Variabili di classe / statiche

• Le variabili di classe note anche come variabili statiche vengono dichiarate con la parola chiave static in una classe, ma al di fuori di un metodo, un costruttore o un blocco.

• Ci sarebbe solo una copia di ogni variabile di classe per classe, indipendentemente dal numero di oggetti creati da essa.

• Le variabili statiche sono usate raramente oltre a essere dichiarate come costanti. Le costanti sono variabili dichiarate come pubbliche / private, finali e statiche. Le variabili costanti non cambiano mai dal loro valore iniziale.

• Le variabili statiche vengono archiviate nella memoria statica. È raro utilizzare variabili statiche diverse da quelle dichiarate final e utilizzate come costanti pubbliche o private.

• Le variabili statiche vengono create all'avvio del programma e distrutte quando il programma si interrompe.

• La visibilità è simile alle variabili di istanza. Tuttavia, la maggior parte delle variabili statiche sono dichiarate pubbliche poiché devono essere disponibili per gli utenti della classe.

• I valori predefiniti sono gli stessi delle variabili di istanza. Per i numeri, il valore predefinito è 0; per i booleani è falso; e per i riferimenti a oggetti, è nullo. I valori possono essere assegnati durante la dichiarazione o all'interno del costruttore. Inoltre, i valori possono essere assegnati in speciali blocchi di inizializzazione statici.

• È possibile accedere alle variabili statiche chiamando con il nome della classe ClassName.VariableName .

• Quando si dichiarano le variabili di classe come finale statico pubblico, i nomi delle variabili (costanti) sono tutti in maiuscolo. Se le variabili statiche non sono pubbliche e finali, la sintassi dei nomi è la stessa delle variabili istanza e locali.

Esempio

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

Questo produrrà il seguente risultato:

Produzione

Development average salary:1000

Note - Se si accede alle variabili da una classe esterna, è necessario accedere alla costante come Employee.DEPARTMENT

Cosa c'è dopo?

Hai già utilizzato i modificatori di accesso (pubblico e privato) in questo capitolo. Il prossimo capitolo spiegherà in dettaglio i modificatori di accesso e quelli non di accesso.

I modificatori sono parole chiave che aggiungi a tali definizioni per cambiarne il significato. Il linguaggio Java ha un'ampia varietà di modificatori, inclusi i seguenti:

• Modificatori di accesso Java

• Modificatori non di accesso

Per utilizzare un modificatore, includi la sua parola chiave nella definizione di una classe, metodo o variabile. Il modificatore precede il resto dell'istruzione, come nell'esempio seguente.

Esempio

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

Modificatori del controllo di accesso

Java fornisce una serie di modificatori di accesso per impostare i livelli di accesso per classi, variabili, metodi e costruttori. I quattro livelli di accesso sono:

• Visibile al pacchetto, predefinito. Non sono necessari modificatori.
• Visibile solo alla classe (privato).
• Visibile al mondo (pubblico).
• Visibile al pacchetto e tutte le sottoclassi (protette).

Modificatori di non accesso

Java fornisce una serie di modificatori di non accesso per ottenere molte altre funzionalità.

• Il modificatore statico per la creazione di variabili e metodi di classe.

• Il modificatore finale per finalizzare le implementazioni di classi, metodi e variabili.

• Il modificatore astratto per creare classi e metodi astratti.

• I modificatori sincronizzati e volatili , utilizzati per i thread.

Cosa c'è dopo?

Nella sezione successiva, discuteremo degli operatori di base utilizzati nel linguaggio Java. Il capitolo fornirà una panoramica di come questi operatori possono essere utilizzati durante lo sviluppo dell'applicazione.

Java fornisce una ricca serie di operatori per manipolare le variabili. Possiamo dividere tutti gli operatori Java nei seguenti gruppi:

• Operatori aritmetici
• Operatori relazionali
• Operatori bit per bit
• Operatori logici
• Operatori di assegnazione
• Operatori vari

Gli operatori aritmetici

Gli operatori aritmetici vengono utilizzati nelle espressioni matematiche nello stesso modo in cui vengono utilizzati in algebra. La tabella seguente elenca gli operatori aritmetici:

Supponiamo che la variabile intera A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
+ (Aggiunta)	Aggiunge valori su entrambi i lati dell'operatore.	A + B darà 30
- (Sottrazione)	Sottrae l'operando di destra dall'operando di sinistra.	A - B darà -10
* (Moltiplicazione)	Moltiplica i valori su entrambi i lati dell'operatore.	A * B darà 200
/ (Divisione)	Divide l'operando di sinistra per l'operando di destra.	B / A darà 2
% (Modulo)	Divide l'operando di sinistra per l'operando di destra e restituisce il resto.	B% A darà 0
++ (incremento)	Aumenta il valore dell'operando di 1.	B ++ dà 21
- (Decremento)	Diminuisce il valore dell'operando di 1.	B-- dà 19

Gli operatori relazionali

Sono disponibili i seguenti operatori relazionali supportati dal linguaggio Java.

Supponiamo che la variabile A contenga 10 e la variabile B ne contenga 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
== (uguale a)	Controlla se i valori di due operandi sono uguali o meno, in caso affermativo la condizione diventa vera.	(A == B) non è vero.
! = (non uguale a)	Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(A! = B) è vero.
> (maggiore di)	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> B) non è vero.
<(minore di)	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <B) è vero.
> = (maggiore o uguale a)	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> = B) non è vero.
<= (minore o uguale a)	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <= B) è vero.

Gli operatori bit per bit

Java definisce diversi operatori bit per bit, che possono essere applicati ai tipi interi, long, int, short, char e byte.

L'operatore bit per bit lavora sui bit ed esegue operazioni bit per bit. Assumiamo se a = 60 eb = 13; ora in formato binario saranno i seguenti -

a = 0011 1100

b = 0000 1101

-----------------

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

La tabella seguente elenca gli operatori bit per bit:

Supponiamo che la variabile intera A contenga 60 e la variabile B contenga 13, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
& (bit a bit e)	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(A e B) darà 12 che è 0000 1100
| (bit a bit o)	L'operatore OR binario copia un bit se esiste in uno degli operandi.	(A | B) darà 61 che è 0011 1101
^ (XOR bit per bit)	L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi.	(A ^ B) darà 49 che è 0011 0001
~ (complimento bit per bit)	Binary Ones Complement Operator è unario e ha l'effetto di "ribaltare" i bit.	(~ A) darà -61 che è 1100 0011 in forma di complemento a 2 a causa di un numero binario con segno.
<< (spostamento a sinistra)	Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra.	Un << 2 darà 240 che è 1111 0000
>> (spostamento a destra)	Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra.	Un >> 2 darà 15 che è 1111
>>> (zero riempimento a destra shift)	Sposta l'operatore di riempimento con zero a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra e i valori spostati vengono riempiti con zeri.	Un >>> 2 darà 15 che è 0000 1111

Gli operatori logici

La tabella seguente elenca gli operatori logici:

Supponiamo che le variabili booleane A siano vere e la variabile B sia falsa, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
&& (logico e)	Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera.	(A && B) è falso
|| (logico o)	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(A || B) è vero
! (logico non)	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (A && B) è vero

Gli operatori di assegnazione

Di seguito sono riportati gli operatori di assegnazione supportati dal linguaggio Java:

Mostra esempi

Operatore	Descrizione	Esempio
=	Operatore di assegnazione semplice. Assegna i valori dagli operandi del lato destro all'operando del lato sinistro.	C = A + B assegnerà il valore di A + B a C
+ =	Aggiungi operatore di assegnazione AND. Aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro.	C + = A è equivalente a C = C + A
- =	Sottrai AND operatore di assegnazione. Sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro.	C - = A è equivalente a C = C - A
* =	Moltiplica AND operatore di assegnazione. Moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro.	C * = A è equivalente a C = C * A
/ =	Divide AND operatore di assegnazione. Divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro.	C / = A è equivalente a C = C / A
% =	Modulo AND operatore di assegnazione. Richiede il modulo utilizzando due operandi e assegna il risultato all'operando sinistro.	C% = A è equivalente a C = C% A
<< =	Shift sinistro AND operatore di assegnazione.	C << = 2 è uguale a C = C << 2
>> =	Spostamento a destra e operatore di assegnazione.	C >> = 2 è uguale a C = C >> 2
& =	Operatore di assegnazione AND bit per bit.	C & = 2 è uguale a C = C & 2
^ =	OR bit per bit esclusivo e operatore di assegnazione.	C ^ = 2 è uguale a C = C ^ 2
| =	OR bit per bit inclusivo e operatore di assegnazione.	C | = 2 è uguale a C = C | 2

Operatori vari

Ci sono pochi altri operatori supportati da Java Language.

Operatore condizionale (?:)

L'operatore condizionale è noto anche come ternary operator. Questo operatore è composto da tre operandi e viene utilizzato per valutare le espressioni booleane. L'obiettivo dell'operatore è decidere quale valore assegnare alla variabile. L'operatore è scritto come -

variable x = (expression) ? value if true : value if false

Di seguito è riportato un esempio:

Example

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

Questo produrrà il seguente risultato:

Output

Value of b is : 30
Value of b is : 20

instanceof Operator

Questo operatore viene utilizzato solo per le variabili di riferimento degli oggetti. L'operatore controlla se l'oggetto è di un tipo particolare (tipo di classe o tipo di interfaccia). L'operatore instanceof è scritto come -

( Object reference variable ) instanceof  (class/interface type)

Se l'oggetto a cui fa riferimento la variabile sul lato sinistro dell'operatore supera il controllo IS-A per il tipo di classe / interfaccia sul lato destro, il risultato sarà vero. Di seguito è riportato un esempio:

Example

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

Questo produrrà il seguente risultato:

Output

true

Questo operatore restituirà comunque true, se l'oggetto da confrontare è l'assegnazione compatibile con il tipo a destra. Di seguito è riportato un altro esempio:

Example

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

Questo produrrà il seguente risultato:

Output

true

Precedenza degli operatori Java

La precedenza degli operatori determina il raggruppamento dei termini in un'espressione. Ciò influisce sul modo in cui viene valutata un'espressione. Alcuni operatori hanno la precedenza maggiore di altri; ad esempio, l'operatore di moltiplicazione ha una precedenza maggiore dell'operatore di addizione -

Ad esempio, x = 7 + 3 * 2; qui x è assegnato 13, non 20 perché l'operatore * ha una precedenza maggiore di +, quindi viene prima moltiplicato per 3 * 2 e quindi somma in 7.

Qui, gli operatori con la precedenza più alta vengono visualizzati nella parte superiore della tabella, quelli con la priorità più bassa in fondo. All'interno di un'espressione, verranno valutati per primi gli operatori con precedenza più alta.

Categoria	Operatore	Associatività
Postfix	espressione ++ espressione--	Da sinistra a destra
Unario	++ espressione –-espressione + espressione –expression ~!	Da destra a sinistra
Moltiplicativo	* /%	Da sinistra a destra
Additivo	+ -	Da sinistra a destra
Cambio	<< >> >>>	Da sinistra a destra
Relazionale	<> <=> = instanceof	Da sinistra a destra
Uguaglianza	==! =	Da sinistra a destra
Bitwise AND	&	Da sinistra a destra
Bitwise XOR	^	Da sinistra a destra
OR bit per bit	|	Da sinistra a destra
AND logico	&&	Da sinistra a destra
OR logico	||	Da sinistra a destra
Condizionale	?:	Da destra a sinistra
Incarico	= + = - = * = / =% = ^ = | = << = >> = >>> =	Da destra a sinistra

Cosa c'è dopo?

Il prossimo capitolo spiegherà il controllo del loop nella programmazione Java. Il capitolo descriverà vari tipi di loop e come questi loop possono essere utilizzati nello sviluppo di programmi Java e per quali scopi vengono utilizzati.

Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. In generale, le istruzioni vengono eseguite in sequenza: la prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

UN loop L'istruzione ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione di ciclo nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione Java fornisce i seguenti tipi di loop per gestire i requisiti di loop. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No.	Loop e descrizione
1	while loop Ripete un'istruzione o un gruppo di istruzioni finché una determinata condizione è vera. Verifica la condizione prima di eseguire il corpo del ciclo.
2	per loop Esegue più volte una sequenza di istruzioni e abbrevia il codice che gestisce la variabile del ciclo.
3	fare ... mentre loop Come un'istruzione while, tranne per il fatto che verifica la condizione alla fine del corpo del ciclo.

Dichiarazioni di controllo del loop

Le istruzioni di controllo del ciclo cambiano l'esecuzione dalla sua sequenza normale. Quando l'esecuzione esce da un ambito, tutti gli oggetti automatici creati in tale ambito vengono eliminati.

Java supporta le seguenti istruzioni di controllo. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No.	Dichiarazione di controllo e descrizione
1	dichiarazione di interruzione Termina il loop o switch istruzione e trasferisce l'esecuzione all'istruzione immediatamente successiva al ciclo o allo switch.
2	continua dichiarazione Fa sì che il ciclo salti il ​​resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere.

Migliorato per loop in Java

A partire da Java 5, è stato introdotto il ciclo for migliorato. Viene utilizzato principalmente per attraversare la raccolta di elementi, inclusi gli array.

Sintassi

Di seguito è riportata la sintassi del ciclo for migliorato:

for(declaration : expression) {
   // Statements
}

• Declaration- La variabile block appena dichiarata, è di un tipo compatibile con gli elementi dell'array a cui stai accedendo. La variabile sarà disponibile all'interno del blocco for e il suo valore sarà lo stesso dell'elemento dell'array corrente.

• Expression- Questo valuta l'array di cui hai bisogno per il loop. L'espressione può essere una variabile di matrice o una chiamata al metodo che restituisce una matrice.

Esempio

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

Cosa c'è dopo?

Nel capitolo seguente impareremo le istruzioni per il processo decisionale nella programmazione Java.

Le strutture decisionali hanno una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni che devono essere eseguite se la condizione è determinata essere vera e, facoltativamente, altre istruzioni da eseguire se la condizione è determinata essere falso.

Di seguito è riportata la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione Java fornisce i seguenti tipi di istruzioni per il processo decisionale. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No.	Dichiarazione e descrizione
1	istruzione if Un if statement consiste in un'espressione booleana seguita da una o più istruzioni.
2	if ... else dichiarazione Un if statement può essere seguito da un optional else statement, che viene eseguito quando l'espressione booleana è falsa.
3	istruzione if annidata Puoi usarne uno if o else if dichiarazione dentro un'altra if o else if dichiarazione (i).
4	istruzione switch UN switch consente di verificare l'uguaglianza di una variabile rispetto a un elenco di valori.

Il ? : Operatore

Abbiamo coperto conditional operator ? : nel capitolo precedente che può essere utilizzato per sostituire if...elsedichiarazioni. Ha la seguente forma generale:

Exp1 ? Exp2 : Exp3;

Dove Exp1, Exp2 e Exp3 sono espressioni. Notare l'uso e il posizionamento dei due punti.

Per determinare il valore dell'intera espressione, inizialmente viene valutato exp1.

• Se il valore di exp1 è vero, il valore di Exp2 sarà il valore dell'intera espressione.

• Se il valore di exp1 è falso, viene valutato Exp3 e il suo valore diventa il valore dell'intera espressione.

Cosa c'è dopo?

Nel prossimo capitolo, discuteremo della classe Number (nel pacchetto java.lang) e delle sue sottoclassi in Java Language.

Esamineremo alcune delle situazioni in cui utilizzerai le istanze di queste classi piuttosto che i tipi di dati primitivi, nonché classi come la formattazione, le funzioni matematiche che devi conoscere quando lavori con Numbers.

Normalmente, quando lavoriamo con Numbers, utilizziamo tipi di dati primitivi come byte, int, long, double, ecc.

Esempio

int i = 5000;
float gpa = 13.65f;
double mask = 125;

Tuttavia, durante lo sviluppo, ci imbattiamo in situazioni in cui dobbiamo usare oggetti invece di tipi di dati primitivi. Per ottenere ciò, Java forniscewrapper classes.

Tutte le classi wrapper (Integer, Long, Byte, Double, Float, Short) sono sottoclassi della classe astratta Number.

L'oggetto della classe wrapper contiene o racchiude il rispettivo tipo di dati primitivo. Viene chiamata la conversione dei tipi di dati primitivi in ​​oggettoboxing, e questo è curato dal compilatore. Pertanto, mentre si utilizza una classe wrapper, è sufficiente passare il valore del tipo di dati primitivo al costruttore della classe Wrapper.

E l'oggetto wrapper verrà riconvertito in un tipo di dati primitivo e questo processo è chiamato unboxing. IlNumber class fa parte del pacchetto java.lang.

Di seguito è riportato un esempio di boxe e unboxing:

Esempio

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

Questo produrrà il seguente risultato:

Produzione

15

Quando a x viene assegnato un valore intero, il compilatore racchiude il numero intero perché x è un oggetto intero. Successivamente, x viene decompresso in modo che possano essere aggiunti come numero intero.

Metodi numerici

Di seguito è riportato l'elenco dei metodi di istanza implementati da tutte le sottoclassi della classe Number:

Sr.No.	Metodo e descrizione
1	xxxValue () Converte il valore di questo oggetto Number nel tipo di dati xxx e lo restituisce.
2	confrontare con() Confronta questo oggetto Number con l'argomento.
3	equivale() Determina se questo oggetto numero è uguale all'argomento.
4	valore di() Restituisce un oggetto Integer che contiene il valore della primitiva specificata.
5	accordare() Restituisce un oggetto String che rappresenta il valore di un int o Integer specificato.
6	parseInt () Questo metodo viene utilizzato per ottenere il tipo di dati primitivo di una determinata stringa.
7	addominali() Restituisce il valore assoluto dell'argomento.
8	ceil () Restituisce il numero intero più piccolo maggiore o uguale all'argomento. Restituito come doppio.
9	pavimento() Restituisce il numero intero più grande minore o uguale all'argomento. Restituito come doppio.
10	rint () Restituisce il numero intero più vicino in valore all'argomento. Restituito come doppio.
11	il giro() Restituisce il long o int più vicino, come indicato dal tipo di ritorno del metodo all'argomento.
12	min () Restituisce il più piccolo dei due argomenti.
13	max () Restituisce il maggiore dei due argomenti.
14	exp () Restituisce la base dei logaritmi naturali, e, alla potenza dell'argomento.
15	log () Restituisce il logaritmo naturale dell'argomento.
16	pow () Restituisce il valore del primo argomento elevato alla potenza del secondo argomento.
17	sqrt () Restituisce la radice quadrata dell'argomento.
18	peccato() Restituisce il seno del valore double specificato.
19	cos () Restituisce il coseno del valore double specificato.
20	tan () Restituisce la tangente del valore double specificato.
21	come in() Restituisce l'arcoseno del valore double specificato.
22	acos () Restituisce l'arcocoseno del valore double specificato.
23	un'abbronzatura() Restituisce l'arcotangente del valore double specificato.
24	atan2 () Converte le coordinate rettangolari (x, y) in coordinate polari (r, theta) e restituisce theta.
25	toDegrees () Converte l'argomento in gradi.
26	toRadians () Converte l'argomento in radianti.
27	casuale() Restituisce un numero casuale.

Cosa c'è dopo?

Nella prossima sezione, esamineremo la classe Character in Java. Imparerai come utilizzare i caratteri oggetto e il tipo di dati primitivo char in Java.

Normalmente, quando lavoriamo con i caratteri, usiamo tipi di dati primitivi char.

Esempio

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

Tuttavia, durante lo sviluppo, ci imbattiamo in situazioni in cui dobbiamo utilizzare oggetti invece di tipi di dati primitivi. Per ottenere ciò, Java fornisce la classe wrapperCharacter per il tipo di dati primitivo char.

La classe Character offre una serie di metodi di classe utili (cioè statici) per manipolare i caratteri. Puoi creare un oggetto Character con il costruttore di caratteri -

Character ch = new Character('a');

Il compilatore Java creerà anche un oggetto Character in alcune circostanze. Ad esempio, se passi un carattere primitivo a un metodo che si aspetta un oggetto, il compilatore converte automaticamente il carattere in un carattere per te. Questa funzione è chiamata autoboxing o unboxing, se la conversione va nell'altra direzione.

Esempio

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

Sequenze di escape

Un carattere preceduto da una barra rovesciata (\) è una sequenza di escape e ha un significato speciale per il compilatore.

Il carattere di nuova riga (\ n) è stato utilizzato frequentemente in questa esercitazione nelle istruzioni System.out.println () per passare alla riga successiva dopo la stampa della stringa.

La tabella seguente mostra le sequenze di escape Java:

Sequenza di fuga	Descrizione
\ t	Inserisce una tabulazione nel testo a questo punto.
\ b	Inserisce un backspace nel testo a questo punto.
\ n	Inserisce una nuova riga nel testo a questo punto.
\ r	Inserisce un ritorno a capo nel testo a questo punto.
\ f	Inserisce un avanzamento modulo nel testo a questo punto.
\ '	Inserisce un singolo carattere di virgoletta nel testo a questo punto.
\ "	Inserisce un carattere di virgolette doppie nel testo a questo punto.
\\	Inserisce una barra rovesciata nel testo a questo punto.

Quando una sequenza di escape viene rilevata in un'istruzione print, il compilatore la interpreta di conseguenza.

Esempio

Se vuoi inserire virgolette tra virgolette, devi usare la sequenza di escape, \ ", nelle virgolette interne -

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

Questo produrrà il seguente risultato:

Produzione

She said "Hello!" to me.

Metodi di carattere

Di seguito è riportato l'elenco dei metodi di istanza importanti che tutte le sottoclassi della classe Character implementano:

Sr.No.	Metodo e descrizione
1	isLetter () Determina se il valore char specificato è una lettera.
2	isDigit () Determina se il valore char specificato è una cifra.
3	isWhitespace () Determina se il valore char specificato è uno spazio vuoto.
4	isUpperCase () Determina se il valore char specificato è maiuscolo.
5	isLowerCase () Determina se il valore char specificato è minuscolo.
6	toUpperCase () Restituisce la forma maiuscola del valore char specificato.
7	toLowerCase () Restituisce la forma minuscola del valore char specificato.
8	accordare() Restituisce un oggetto String che rappresenta il valore del carattere specificato, ovvero una stringa di un carattere.

Per un elenco completo dei metodi, fare riferimento alla specifica API java.lang.Character.

Cosa c'è dopo?

Nella prossima sezione, esamineremo la classe String in Java. Imparerai come dichiarare e utilizzare le stringhe in modo efficiente, nonché alcuni dei metodi importanti nella classe String.

Le stringhe, ampiamente utilizzate nella programmazione Java, sono una sequenza di caratteri. Nel linguaggio di programmazione Java, le stringhe vengono trattate come oggetti.

La piattaforma Java fornisce la classe String per creare e manipolare le stringhe.

Creazione di stringhe

Il modo più diretto per creare una stringa è scrivere -

String greeting = "Hello world!";

Ogni volta che incontra una stringa letterale nel codice, il compilatore crea un oggetto String con il suo valore in questo caso, "Hello world!".

Come con qualsiasi altro oggetto, puoi creare oggetti String usando la nuova parola chiave e un costruttore. La classe String ha 11 costruttori che consentono di fornire il valore iniziale della stringa utilizzando origini diverse, come un array di caratteri.

Esempio

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

Questo produrrà il seguente risultato:

Produzione

hello.

Note- La classe String è immutabile, quindi una volta creata non è possibile modificare un oggetto String. Se è necessario apportare molte modifiche alle stringhe di caratteri, è necessario utilizzare String Buffer e String Builder Classes.

Lunghezza della stringa

I metodi utilizzati per ottenere informazioni su un oggetto sono noti come accessor methods. Un metodo di accesso che è possibile utilizzare con le stringhe è il metodo length (), che restituisce il numero di caratteri contenuti nell'oggetto stringa.

Il seguente programma è un esempio di length(), metodo String class.

Esempio

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

Questo produrrà il seguente risultato:

Produzione

String Length is : 17

Concatenazione di stringhe

La classe String include un metodo per concatenare due stringhe:

string1.concat(string2);

Ciò restituisce una nuova stringa che è stringa1 con stringa2 aggiunta alla fine. Puoi anche usare il metodo concat () con stringhe letterali, come in -

"My name is ".concat("Zara");

Le stringhe sono più comunemente concatenate con l'operatore +, come in -

"Hello," + " world" + "!"

che si traduce in -

"Hello, world!"

Guardiamo il seguente esempio:

Esempio

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

Questo produrrà il seguente risultato:

Produzione

Dot saw I was Tod

Creazione di stringhe di formato

Hai i metodi printf () e format () per stampare l'output con numeri formattati. La classe String ha un metodo di classe equivalente, format (), che restituisce un oggetto String anziché un oggetto PrintStream.

L'uso del metodo statico format () di String ti consente di creare una stringa formattata che puoi riutilizzare, al contrario di un'istruzione print una tantum. Ad esempio, invece di -

Esempio

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

Puoi scrivere -

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

Metodi di stringa

Ecco l'elenco dei metodi supportati dalla classe String:

Sr.No.	Metodo e descrizione
1	char charAt (int index) Restituisce il carattere all'indice specificato.
2	int compareTo (Oggetto o) Confronta questa stringa con un altro oggetto.
3	int compareTo (String anotherString) Confronta due stringhe lessicograficamente.
4	int compareToIgnoreCase (String str) Confronta due stringhe lessicograficamente, ignorando le differenze tra maiuscole e minuscole.
5	String concat (String str) Concatena la stringa specificata alla fine di questa stringa.
6	booleano contentEquals (StringBuffer sb) Restituisce true se e solo se questa stringa rappresenta la stessa sequenza di caratteri dello StringBuffer specificato.
7	stringa statica copyValueOf (char [] data) Restituisce una stringa che rappresenta la sequenza di caratteri nella matrice specificata.
8	stringa statica copyValueOf (char [] data, int offset, int count) Restituisce una stringa che rappresenta la sequenza di caratteri nella matrice specificata.
9	booleano finisce con (suffisso stringa) Verifica se questa stringa termina con il suffisso specificato.
10	booleano è uguale a (Object anObject) Confronta questa stringa con l'oggetto specificato.
11	booleano è uguale aIgnoreCase (String anotherString) Confronta questa stringa con un'altra stringa, ignorando le considerazioni sul caso.
12	byte getBytes () Codifica questa stringa in una sequenza di byte utilizzando il set di caratteri predefinito della piattaforma, memorizzando il risultato in un nuovo array di byte.
13	byte [] getBytes (String charsetName) Codifica questa stringa in una sequenza di byte utilizzando il set di caratteri denominato, archiviando il risultato in una nuova matrice di byte.
14	void getChars (int srcBegin, int srcEnd, char [] dst, int dstBegin) Copia i caratteri da questa stringa nell'array di caratteri di destinazione.
15	int hashCode () Restituisce un codice hash per questa stringa.
16	int indexOf (int ch) Restituisce l'indice all'interno di questa stringa della prima occorrenza del carattere specificato.
17	int indexOf (int ch, int fromIndex) Restituisce l'indice all'interno di questa stringa della prima occorrenza del carattere specificato, iniziando la ricerca dall'indice specificato.
18	int indexOf (String str) Restituisce l'indice all'interno di questa stringa della prima occorrenza della sottostringa specificata.
19	int indexOf (String str, int fromIndex) Restituisce l'indice all'interno di questa stringa della prima occorrenza della sottostringa specificata, a partire dall'indice specificato.
20	String intern () Restituisce una rappresentazione canonica per l'oggetto stringa.
21	int lastIndexOf (int ch) Restituisce l'indice all'interno di questa stringa dell'ultima occorrenza del carattere specificato.
22	int lastIndexOf (int ch, int fromIndex) Restituisce l'indice all'interno di questa stringa dell'ultima occorrenza del carattere specificato, cercando all'indietro a partire dall'indice specificato.
23	int lastIndexOf (String str) Restituisce l'indice all'interno di questa stringa dell'occorrenza più a destra della sottostringa specificata.
24	int lastIndexOf (String str, int fromIndex) Restituisce l'indice all'interno di questa stringa dell'ultima occorrenza della sottostringa specificata, cercando all'indietro a partire dall'indice specificato.
25	int length () Restituisce la lunghezza di questa stringa.
26	corrispondenze booleane (stringa regex) Indica se questa stringa corrisponde o meno all'espressione regolare data.
27	boolean regionMatches (boolean ignoreCase, int toffset, String other, int ooffset, int len) Verifica se due regioni di stringa sono uguali.
28	boolean regionMatches (int toffset, String other, int ooffset, int len) Verifica se due regioni di stringa sono uguali.
29	Sostituisci stringa (char oldChar, char newChar) Restituisce una nuova stringa risultante dalla sostituzione di tutte le occorrenze di oldChar in questa stringa con newChar.
30	String replaceAll (String regex, String replacement Sostituisce ogni sottostringa di questa stringa che corrisponde all'espressione regolare data con la sostituzione data.
31	String replaceFirst (String regex, String replacement) Sostituisce la prima sottostringa di questa stringa che corrisponde all'espressione regolare data con la sostituzione data.
32	String [] split (String regex) Divide questa stringa attorno alle corrispondenze dell'espressione regolare data.
33	String [] split (String regex, int limit) Divide questa stringa attorno alle corrispondenze dell'espressione regolare data.
34	booleano inizia con (prefisso stringa) Verifica se questa stringa inizia con il prefisso specificato.
35	boolean startsWith (String prefix, int toffset) Verifica se questa stringa inizia con il prefisso specificato all'inizio di un indice specificato.
36	CharSequence subSequence (int beginIndex, int endIndex) Restituisce una nuova sequenza di caratteri che è una sottosequenza di questa sequenza.
37	Sottostringa stringa (int beginIndex) Restituisce una nuova stringa che è una sottostringa di questa stringa.
38	Sottostringa stringa (int beginIndex, int endIndex) Restituisce una nuova stringa che è una sottostringa di questa stringa.
39	char [] toCharArray () Converte questa stringa in un nuovo array di caratteri.
40	String toLowerCase () Converte tutti i caratteri in questa stringa in minuscolo utilizzando le regole della locale predefinita.
41	String toLowerCase (impostazioni internazionali locali) Converte tutti i caratteri in questa stringa in minuscolo utilizzando le regole delle impostazioni internazionali specificate.
42	String toString () Questo oggetto (che è già una stringa!) Viene restituito.
43	String toUpperCase () Converte tutti i caratteri in questa stringa in lettere maiuscole utilizzando le regole della locale predefinita.
44	String toUpperCase (Locale locale) Converte tutti i caratteri in questa stringa in lettere maiuscole utilizzando le regole delle impostazioni internazionali specificate.
45	Taglio delle corde () Restituisce una copia della stringa, omettendo gli spazi iniziali e finali.
46	static String valueOf (tipo di dati primitivo x) Restituisce la rappresentazione di stringa dell'argomento del tipo di dati passato.

Java fornisce una struttura dati, il array, che archivia una raccolta sequenziale a dimensione fissa di elementi dello stesso tipo. Un array viene utilizzato per memorizzare una raccolta di dati, ma spesso è più utile pensare a un array come una raccolta di variabili dello stesso tipo.

Invece di dichiarare variabili individuali, come numero0, numero1, ... e numero99, dichiari una variabile di matrice come numeri e utilizzi numeri [0], numeri [1] e ..., numeri [99] per rappresentare variabili individuali.

Questo tutorial introduce come dichiarare variabili di array, creare array ed elaborare array utilizzando variabili indicizzate.

Dichiarazione di variabili array

Per utilizzare un array in un programma, è necessario dichiarare una variabile per fare riferimento all'array e specificare il tipo di array a cui la variabile può fare riferimento. Ecco la sintassi per dichiarare una variabile di matrice:

Sintassi

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

Note - Lo stile dataType[] arrayRefVarè preferito. Lo stiledataType arrayRefVar[] proviene dal linguaggio C / C ++ ed è stato adottato in Java per accogliere i programmatori C / C ++.

Esempio

I seguenti frammenti di codice sono esempi di questa sintassi:

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

Creazione di array

È possibile creare un array utilizzando il nuovo operatore con la seguente sintassi:

Sintassi

arrayRefVar = new dataType[arraySize];

L'affermazione precedente fa due cose:

• Crea un array utilizzando il nuovo dataType [arraySize].

• Assegna il riferimento dell'array appena creato alla variabile arrayRefVar.

La dichiarazione di una variabile di matrice, la creazione di una matrice e l'assegnazione del riferimento della matrice alla variabile possono essere combinate in un'unica istruzione, come mostrato di seguito:

dataType[] arrayRefVar = new dataType[arraySize];

In alternativa puoi creare array come segue:

dataType[] arrayRefVar = {value0, value1, ..., valuek};

Gli elementi dell'array sono accessibili tramite index. Gli indici di matrice sono a base 0; cioè, iniziano da 0 aarrayRefVar.length-1.

Esempio

La seguente dichiarazione dichiara una variabile di array, myList, crea un array di 10 elementi di tipo double e assegna il suo riferimento a myList -

double[] myList = new double[10];

L'immagine seguente rappresenta la matrice myList. Qui, myList contiene dieci valori doppi e gli indici vanno da 0 a 9.

Elaborazione di array

Quando elaboriamo gli elementi dell'array, spesso usiamo entrambi for loop o foreach perché tutti gli elementi in un array sono dello stesso tipo e la dimensione dell'array è nota.

Esempio

Ecco un esempio completo che mostra come creare, inizializzare ed elaborare array:

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

Questo produrrà il seguente risultato:

Produzione

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

I loop foreach

JDK 1.5 ha introdotto un nuovo ciclo for noto come ciclo foreach o ciclo for migliorato, che consente di attraversare l'array completo in modo sequenziale senza utilizzare una variabile di indice.

Esempio

Il codice seguente mostra tutti gli elementi nell'array myList -

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

1.9
2.9
3.4
3.5

Passaggio di array a metodi

Proprio come puoi passare valori di tipo primitivo ai metodi, puoi anche passare array ai metodi. Ad esempio, il metodo seguente visualizza gli elementi in un fileint matrice -

Esempio

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

Puoi invocarlo passando un array. Ad esempio, la seguente istruzione richiama il metodo printArray per visualizzare 3, 1, 2, 6, 4 e 2 -

Esempio

printArray(new int[]{3, 1, 2, 6, 4, 2});

Restituzione di un array da un metodo

Un metodo può anche restituire un array. Ad esempio, il metodo seguente restituisce un array che è l'inversione di un altro array:

Esempio

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

La classe Arrays

La classe java.util.Arrays contiene vari metodi statici per ordinare e cercare array, confrontare array e riempire gli elementi dell'array. Questi metodi sono sovraccaricati per tutti i tipi primitivi.

Sr.No.	Metodo e descrizione
1	public static int binarySearch(Object[] a, Object key) Cerca nell'array specificato di Object (Byte, Int, double e così via) il valore specificato utilizzando l'algoritmo di ricerca binaria. L'array deve essere ordinato prima di effettuare questa chiamata. Restituisce l'indice della chiave di ricerca, se è contenuta nell'elenco; in caso contrario, restituisce (- (punto di inserimento + 1)).
2	public static boolean equals(long[] a, long[] a2) Restituisce vero se i due array di long specificati sono uguali tra loro. Due array sono considerati uguali se entrambi gli array contengono lo stesso numero di elementi e tutte le coppie di elementi corrispondenti nei due array sono uguali. Restituisce true se i due array sono uguali. Lo stesso metodo potrebbe essere utilizzato da tutti gli altri tipi di dati primitivi (Byte, short, Int, ecc.)
3	public static void fill(int[] a, int val) Assegna il valore int specificato a ogni elemento dell'array di int specificato. Lo stesso metodo potrebbe essere utilizzato da tutti gli altri tipi di dati primitivi (Byte, short, Int, ecc.)
4	public static void sort(Object[] a) Ordina la matrice di oggetti specificata in ordine crescente, in base all'ordinamento naturale dei suoi elementi. Lo stesso metodo potrebbe essere utilizzato da tutti gli altri tipi di dati primitivi (Byte, short, Int, ecc.)

Java fornisce l'estensione Date classe disponibile in java.util pacchetto, questa classe incapsula la data e l'ora correnti.

La classe Date supporta due costruttori come mostrato nella tabella seguente.

Sr.No.	Costruttore e descrizione
1	Date( ) Questo costruttore inizializza l'oggetto con la data e l'ora correnti.
2	Date(long millisec) Questo costruttore accetta un argomento che equivale al numero di millisecondi trascorsi dalla mezzanotte del 1 gennaio 1970.

Di seguito sono riportati i metodi della classe date.

Sr.No.	Metodo e descrizione
1	boolean after(Date date) Restituisce true se l'oggetto Date che richiama contiene una data successiva a quella specificata da date, altrimenti restituisce false.
2	boolean before(Date date) Restituisce true se l'oggetto Date che richiama contiene una data precedente a quella specificata da date, altrimenti restituisce false.
3	Object clone( ) Duplica l'oggetto Date che richiama.
4	int compareTo(Date date) Confronta il valore dell'oggetto invocante con quello di date. Restituisce 0 se i valori sono uguali. Restituisce un valore negativo se l'oggetto che richiama è precedente alla data. Restituisce un valore positivo se l'oggetto che richiama è successivo alla data.
5	int compareTo(Object obj) Funziona in modo identico a compareTo (Date) se obj è della classe Date. In caso contrario, genera un'eccezione ClassCastException.
6	boolean equals(Object date) Restituisce true se l'oggetto Date che richiama contiene la stessa ora e data di quella specificata da date, altrimenti restituisce false.
7	long getTime( ) Restituisce il numero di millisecondi trascorsi dal 1 gennaio 1970.
8	int hashCode( ) Restituisce un codice hash per l'oggetto che richiama.
9	void setTime(long time) Imposta l'ora e la data come specificato da time, che rappresenta il tempo trascorso in millisecondi dalla mezzanotte del 1 gennaio 1970.
10	String toString( ) Converte l'oggetto Date che richiama in una stringa e restituisce il risultato.

Ottenere la data e l'ora correnti

Questo è un metodo molto semplice per ottenere la data e l'ora correnti in Java. È possibile utilizzare un semplice oggetto Date con il metodo toString () per stampare la data e l'ora correnti come segue:

Esempio

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

Questo produrrà il seguente risultato:

Produzione

on May 04 09:51:52 CDT 2009

Confronto delle date

Di seguito sono riportati i tre modi per confrontare due date:

• È possibile utilizzare getTime () per ottenere il numero di millisecondi trascorsi dalla mezzanotte del 1 gennaio 1970 per entrambi gli oggetti e quindi confrontare questi due valori.

• È possibile utilizzare i metodi before (), after () ed equals (). Poiché il 12 del mese precede il 18, ad esempio, new Date (99, 2, 12) .before (new Date (99, 2, 18)) restituisce true.

• È possibile utilizzare il metodo compareTo (), definito dall'interfaccia Comparable e implementato da Date.

Formattazione della data utilizzando SimpleDateFormat

SimpleDateFormat è una classe concreta per la formattazione e l'analisi delle date in modo sensibile alle impostazioni locali. SimpleDateFormat consente di iniziare scegliendo qualsiasi modello definito dall'utente per la formattazione della data e dell'ora.

Esempio

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Questo produrrà il seguente risultato:

Produzione

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

Codici di formato DateFormat semplici

Per specificare il formato dell'ora, utilizzare una stringa del modello dell'ora. In questo modello, tutte le lettere ASCII sono riservate come lettere del modello, che sono definite come segue:

Personaggio	Descrizione	Esempio
G	Designatore di epoca	ANNO DOMINI
y	Anno in quattro cifre	2001
M	Mese nell'anno	Luglio o 07
d	Giorno in mese	10
h	Ora AM / PM (1 ~ 12)	12
H	Ora nel giorno (0 ~ 23)	22
m	Minuto in ora	30
S	Secondo in minuto	55
S	Millisecondo	234
E	Giorno in settimana	martedì
D	Giorno dell'anno	360
F	Giorno della settimana nel mese	2 (secondo mercoledì di luglio)
w	Settimana nell'anno	40
W	Settimana al mese	1
un	Indicatore AM / PM	PM
K	Ora nel giorno (1 ~ 24)	24
K	Ora AM / PM (0 ~ 11)	10
z	Fuso orario	Ora solare orientale
'	Fuga per il testo	Delimitatore
"	Virgoletta singola	"

Formattazione della data utilizzando printf

La formattazione di data e ora può essere eseguita molto facilmente utilizzando printfmetodo. Utilizzi un formato di due lettere, che inizia cont e termina con una delle lettere della tabella come mostrato nel codice seguente.

Esempio

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

Questo produrrà il seguente risultato:

Produzione

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

Sarebbe un po 'sciocco se dovessi fornire la data più volte per formattare ogni parte. Per questo motivo, una stringa di formato può indicare l'indice dell'argomento da formattare.

L'indice deve seguire immediatamente% e deve essere terminato da $.

Esempio

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

Questo produrrà il seguente risultato:

Produzione

Due date: February 09, 2004

In alternativa, puoi usare il flag <. Indica che lo stesso argomento della specifica di formato precedente deve essere utilizzato di nuovo.

Esempio

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

Questo produrrà il seguente risultato:

Produzione

Due date: February 09, 2004

Caratteri di conversione di data e ora

Personaggio	Descrizione	Esempio
c	Data e ora complete	Lunedì 04 maggio 09:51:52 CDT 2009
F	Data ISO 8601	2004-02-09
D	Data formattata USA (mese / giorno / anno)	02/09/2004
T	24 ore su 24	18:05:19
r	12 ore	18:05:19
R	24 ore su 24, senza secondi	18:05
Y	Anno a quattro cifre (con zeri iniziali)	2004
y	Ultime due cifre dell'anno (con zeri iniziali)	04
C	Prime due cifre dell'anno (con zeri iniziali)	20
B	Nome completo del mese	febbraio
b	Nome del mese abbreviato	Feb
m	Mese a due cifre (con zeri iniziali)	02
d	Giorno a due cifre (con zeri iniziali)	03
e	Giorno a due cifre (senza zeri iniziali)	9
UN	Nome completo del giorno della settimana	Lunedi
un	Nome abbreviato del giorno della settimana	Lun
j	Giorno dell'anno a tre cifre (con zeri iniziali)	069
H	Ora a due cifre (con zeri iniziali), compresa tra 00 e 23	18
K	Ora a due cifre (senza zeri iniziali), compresa tra 0 e 23	18
io	Ora a due cifre (con zeri iniziali), compresa tra 01 e 12	06
l	Ora a due cifre (senza zeri iniziali), compresa tra 1 e 12	6
M	Minuti a due cifre (con zeri iniziali)	05
S	Secondi a due cifre (con zeri iniziali)	19
L	Millisecondi a tre cifre (con zeri iniziali)	047
N	Nanosecondi a nove cifre (con zeri iniziali)	047000000
P	Indicatore mattutino o pomeridiano maiuscolo	PM
p	Indicatore mattutino o pomeridiano minuscolo	pm
z	RFC 822 offset numerico dal GMT	-0800
Z	Fuso orario	PST
S	Secondi da 1970-01-01 00:00:00 GMT	1078884319
Q	Millisecondi da 1970-01-01 00:00:00 GMT	1078884319047

Ci sono altre classi utili relative a Data e ora. Per ulteriori dettagli, fare riferimento alla documentazione di Java Standard.

Analisi delle stringhe nelle date

La classe SimpleDateFormat ha alcuni metodi aggiuntivi, in particolare parse (), che cerca di analizzare una stringa in base al formato memorizzato nell'oggetto SimpleDateFormat specificato.

Esempio

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

Un'esecuzione di esempio del programma precedente produrrebbe il seguente risultato:

Produzione

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

Dormire per un po '

Puoi dormire per qualsiasi periodo di tempo da un millisecondo fino alla durata del tuo computer. Ad esempio, il seguente programma dormirà per 3 secondi:

Esempio

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

Misurazione del tempo trascorso

A volte, potrebbe essere necessario misurare il punto nel tempo in millisecondi. Quindi riscriviamo ancora una volta l'esempio precedente -

Esempio

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993

Classe GregorianCalendar

GregorianCalendar è un'implementazione concreta di una classe Calendar che implementa il normale calendario gregoriano con cui hai familiarità. Non abbiamo discusso della classe Calendar in questo tutorial, puoi cercare la documentazione Java standard per questo.

Il getInstance( )Il metodo di Calendar restituisce un GregorianCalendar inizializzato con la data e l'ora correnti nella lingua e nel fuso orario predefiniti. GregorianCalendar definisce due campi: AD e BC. Questi rappresentano le due epoche definite dal calendario gregoriano.

Esistono anche diversi costruttori per oggetti GregorianCalendar:

Sr.No.	Costruttore e descrizione
1	GregorianCalendar() Costruisce un GregorianCalendar predefinito utilizzando l'ora corrente nel fuso orario predefinito con le impostazioni internazionali predefinite.
2	GregorianCalendar(int year, int month, int date) Costruisce un GregorianCalendar con la data specificata impostata nel fuso orario predefinito con la locale predefinita.
3	GregorianCalendar(int year, int month, int date, int hour, int minute) Costruisce un GregorianCalendar con la data e l'ora specificate impostate per il fuso orario predefinito con le impostazioni internazionali predefinite.
4	GregorianCalendar(int year, int month, int date, int hour, int minute, int second) Costruisce un GregorianCalendar con la data e l'ora specificate impostate per il fuso orario predefinito con le impostazioni internazionali predefinite.
5	GregorianCalendar(Locale aLocale) Costruisce un GregorianCalendar basato sull'ora corrente nel fuso orario predefinito con la locale specificata.
6	GregorianCalendar(TimeZone zone) Costruisce un GregorianCalendar basato sull'ora corrente nel fuso orario specificato con la locale predefinita.
7	GregorianCalendar(TimeZone zone, Locale aLocale) Costruisce un GregorianCalendar basato sull'ora corrente nel fuso orario specificato con la locale specificata.

Ecco l'elenco di alcuni metodi di supporto utili forniti dalla classe GregorianCalendar:

Sr.No.	Metodo e descrizione
1	void add(int field, int amount) Aggiunge la quantità di tempo specificata (con segno) al campo dell'ora specificato, in base alle regole del calendario.
2	protected void computeFields() Converte UTC in millisecondi in valori di campo ora.
3	protected void computeTime() Sostituisce il calendario Converte i valori del campo ora in UTC in millisecondi.
4	boolean equals(Object obj) Confronta questo GregorianCalendar con un riferimento a un oggetto.
5	int get(int field) Ottiene il valore per un determinato campo temporale.
6	int getActualMaximum(int field) Restituisce il valore massimo che questo campo potrebbe avere, data la data corrente.
7	int getActualMinimum(int field) Restituisce il valore minimo che questo campo potrebbe avere, data la data corrente.
8	int getGreatestMinimum(int field) Restituisce il valore minimo più alto per il campo specificato, se varia.
9	Date getGregorianChange() Ottiene la data di modifica del calendario gregoriano.
10	int getLeastMaximum(int field) Restituisce il valore massimo più basso per il campo specificato se varia.
11	int getMaximum(int field) Restituisce il valore massimo per il campo specificato.
12	Date getTime() Ottiene l'ora corrente di questo calendario.
13	long getTimeInMillis() Ottiene l'ora corrente di questo calendario come long.
14	TimeZone getTimeZone() Ottiene il fuso orario.
15	int getMinimum(int field) Restituisce il valore minimo per il campo specificato.
16	int hashCode() Esegue l'override di hashCode.
17	boolean isLeapYear(int year) Determina se l'anno specificato è un anno bisestile.
18	void roll(int field, boolean up) Aggiunge o sottrae (su / giù) una singola unità di tempo nel campo temporale specificato senza modificare i campi più grandi.
19	void set(int field, int value) Imposta il campo dell'ora con il valore dato.
20	void set(int year, int month, int date) Imposta i valori per i campi anno, mese e data.
21	void set(int year, int month, int date, int hour, int minute) Imposta i valori per i campi anno, mese, data, ora e minuto.
22	void set(int year, int month, int date, int hour, int minute, int second) Imposta i valori per i campi anno, mese, data, ora, minuti e secondi.
23	void setGregorianChange(Date date) Imposta la data di modifica di GregorianCalendar.
24	void setTime(Date date) Imposta l'ora corrente di questo calendario con la data specificata.
25	void setTimeInMillis(long millis) Imposta l'ora corrente di questo calendario dal valore long specificato.
26	void setTimeZone(TimeZone value) Imposta il fuso orario con il valore del fuso orario specificato.
27	String toString() Restituisce una rappresentazione di stringa di questo calendario.

Esempio

import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year

Per un elenco completo delle costanti disponibili nella classe Calendar, è possibile fare riferimento alla documentazione Java standard.

Java fornisce il pacchetto java.util.regex per la corrispondenza dei modelli con le espressioni regolari. Le espressioni regolari Java sono molto simili al linguaggio di programmazione Perl e molto facili da imparare.

Un'espressione regolare è una sequenza speciale di caratteri che consente di abbinare o trovare altre stringhe o gruppi di stringhe, utilizzando una sintassi specializzata contenuta in un modello. Possono essere utilizzati per cercare, modificare o manipolare testo e dati.

Il pacchetto java.util.regex consiste principalmente delle seguenti tre classi:

• Pattern Class- Un oggetto Pattern è una rappresentazione compilata di un'espressione regolare. La classe Pattern non fornisce costruttori pubblici. Per creare un pattern, devi prima richiamare uno dei suoi statici pubblicicompile()metodi, che restituiranno quindi un oggetto Pattern. Questi metodi accettano un'espressione regolare come primo argomento.

• Matcher Class- Un oggetto Matcher è il motore che interpreta il modello ed esegue operazioni di corrispondenza su una stringa di input. Come la classe Pattern, Matcher non definisce alcun costruttore pubblico. Ottieni un oggetto Matcher invocando il filematcher() metodo su un oggetto Pattern.

• PatternSyntaxException - Un oggetto PatternSyntaxException è un'eccezione non controllata che indica un errore di sintassi in un modello di espressione regolare.

Acquisizione di gruppi

La cattura di gruppi è un modo per trattare più personaggi come una singola unità. Vengono creati inserendo i caratteri da raggruppare all'interno di una serie di parentesi. Ad esempio, l'espressione regolare (cane) crea un singolo gruppo contenente le lettere "d", "o" e "g".

I gruppi di cattura vengono numerati contando le loro parentesi di apertura da sinistra a destra. Nell'espressione ((A) (B (C))), ad esempio, ci sono quattro di questi gruppi:

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

Per scoprire quanti gruppi sono presenti nell'espressione, chiama il metodo groupCount su un oggetto matcher. Il metodo groupCount restituisce un fileint mostrando il numero di gruppi di cattura presenti nel modello del matcher.

C'è anche un gruppo speciale, il gruppo 0, che rappresenta sempre l'intera espressione. Questo gruppo non è incluso nel totale riportato da groupCount.

Example

L'esempio seguente illustra come trovare una stringa di cifre dalla stringa alfanumerica data:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

Questo produrrà il seguente risultato:

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Sintassi delle espressioni regolari

Ecco la tabella che elenca tutta la sintassi dei metacaratteri delle espressioni regolari disponibile in Java:

Sottoespressione	Partite
^	Corrisponde all'inizio della riga.
$	Corrisponde alla fine della riga.
.	Corrisponde a qualsiasi carattere singolo tranne la nuova riga. Utilizzandom opzione consente di abbinare anche la nuova riga.
[...]	Corrisponde a qualsiasi singolo carattere tra parentesi.
[^ ...]	Corrisponde a qualsiasi carattere singolo non tra parentesi.
\UN	Inizio dell'intera stringa.
\ z	Fine dell'intera stringa.
\ Z	Fine dell'intera stringa eccetto il terminatore di riga finale consentito.
ri*	Corrisponde a 0 o più occorrenze dell'espressione precedente.
re +	Corrisponde a 1 o più elementi precedenti.
ri?	Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
re {n}	Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
re {n,}	Corrisponde a n o più occorrenze dell'espressione precedente.
re {n, m}	Trova almeno n e al massimo m occorrenze dell'espressione precedente.
a | b	Corrisponde a a o b.
(ri)	Raggruppa le espressioni regolari e ricorda il testo corrispondente.
(?: re)	Raggruppa le espressioni regolari senza ricordare il testo corrispondente.
(?> re)	Corrisponde al modello indipendente senza backtracking.
\ w	Corrisponde ai caratteri della parola.
\ W	Corrisponde ai caratteri non di parole.
\S	Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
\S	Corrisponde allo spazio non bianco.
\ d	Corrisponde alle cifre. Equivalente a [0-9].
\ D	Corrisponde alle non cifre.
\UN	Corrisponde all'inizio della stringa.
\ Z	Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
\ z	Corrisponde alla fine della stringa.
\ G	Corrisponde al punto in cui è terminata l'ultima partita.
\ n	Riferimento a ritroso per acquisire il numero di gruppo "n".
\ b	Corrisponde ai confini della parola quando è al di fuori delle parentesi. Corrisponde al backspace (0x08) quando è all'interno delle parentesi.
\ B	Corrisponde ai confini non di parole.
\ n, \ t, ecc.	Trova nuove righe, ritorni a capo, tabulazioni, ecc.
\ Q	Fuga (virgolette) tutti i caratteri fino a \ E.
\ E	Termina la citazione iniziata con \ Q.

Metodi della classe Matcher

Ecco un elenco di metodi di istanza utili:

Metodi di indice

I metodi di indice forniscono valori di indice utili che mostrano esattamente dove è stata trovata la corrispondenza nella stringa di input -

Sr.No.	Metodo e descrizione
1	public int start() Restituisce l'indice iniziale della corrispondenza precedente.
2	public int start(int group) Restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante la precedente operazione di corrispondenza.
3	public int end() Restituisce l'offset dopo l'ultimo carattere trovato.
4	public int end(int group) Restituisce l'offset dopo l'ultimo carattere della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente.

Metodi di studio

I metodi di studio esaminano la stringa di input e restituiscono un valore booleano che indica se il modello viene trovato o meno -

Sr.No.	Metodo e descrizione
1	public boolean lookingAt() Tenta di far corrispondere la sequenza di input, a partire dall'inizio della regione, rispetto al modello.
2	public boolean find() Tenta di trovare la sottosequenza successiva della sequenza di input che corrisponde al modello.
3	public boolean find(int start) Reimposta questo matcher e quindi tenta di trovare la sottosequenza successiva della sequenza di input che corrisponde al modello, a partire dall'indice specificato.
4	public boolean matches() Tenta di far corrispondere l'intera regione rispetto al modello.

Metodi di sostituzione

I metodi di sostituzione sono metodi utili per sostituire il testo in una stringa di input -

Sr.No.	Metodo e descrizione
1	public Matcher appendReplacement(StringBuffer sb, String replacement) Implementa un passaggio di aggiunta e sostituzione non terminale.
2	public StringBuffer appendTail(StringBuffer sb) Implementa un passaggio di aggiunta e sostituzione del terminale.
3	public String replaceAll(String replacement) Sostituisce ogni sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
4	public String replaceFirst(String replacement) Sostituisce la prima sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
5	public static String quoteReplacement(String s) Restituisce una stringa di sostituzione letterale per la stringa specificata. Questo metodo produce una stringa che funzionerà come una sostituzione letterales nel metodo appendReplacement della classe Matcher.

I metodi di inizio e fine

Di seguito è riportato l'esempio che conta il numero di volte in cui la parola "gatto" appare nella stringa di input:

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Questo produrrà il seguente risultato:

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Puoi vedere che questo esempio utilizza i confini delle parole per garantire che le lettere "c" "a" "t" non siano semplicemente una sottostringa in una parola più lunga. Fornisce anche alcune informazioni utili su dove si è verificata la corrispondenza nella stringa di input.

Il metodo start restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente e la fine restituisce l'indice dell'ultimo carattere corrispondente, più uno.

Le partite e i metodi di ricerca

I metodi Match e LookingAt tentano entrambi di trovare una corrispondenza tra una sequenza di input e un pattern. La differenza, tuttavia, è che le corrispondenze richiedono la corrispondenza dell'intera sequenza di input, mentre lookingAt no.

Entrambi i metodi iniziano sempre all'inizio della stringa di input. Ecco l'esempio che spiega la funzionalità:

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

Questo produrrà il seguente risultato:

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

I metodi replaceFirst e replaceAll

I metodi replaceFirst e replaceAll sostituiscono il testo che corrisponde a una data espressione regolare. Come indicano i loro nomi, replaceFirst sostituisce la prima occorrenza e replaceAll sostituisce tutte le occorrenze.

Ecco l'esempio che spiega la funzionalità:

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

Questo produrrà il seguente risultato:

Output

The cat says meow. All cats say meow.

I metodi appendReplacement e appendTail

La classe Matcher fornisce anche metodi appendReplacement e appendTail per la sostituzione del testo.

Ecco l'esempio che spiega la funzionalità:

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Questo produrrà il seguente risultato:

Output

-foo-foo-foo-

Metodi di classe PatternSyntaxException

Una PatternSyntaxException è un'eccezione non controllata che indica un errore di sintassi in un modello di espressione regolare. La classe PatternSyntaxException fornisce i seguenti metodi per aiutarti a determinare cosa è andato storto:

Sr.No.	Metodo e descrizione
1	public String getDescription() Recupera la descrizione dell'errore.
2	public int getIndex() Recupera l'indice di errore.
3	public String getPattern() Recupera il modello di espressione regolare errato.
4	public String getMessage() Restituisce una stringa su più righe contenente la descrizione dell'errore di sintassi e il suo indice, il modello di espressione regolare errato e un'indicazione visiva dell'indice di errore all'interno del modello.

Un metodo Java è una raccolta di istruzioni raggruppate per eseguire un'operazione. Quando chiami System.out.println() metodo, ad esempio, il sistema esegue effettivamente diverse istruzioni per visualizzare un messaggio sulla console.

Ora imparerai come creare i tuoi metodi con o senza valori di ritorno, invocare un metodo con o senza parametri e applicare l'astrazione del metodo nella progettazione del programma.

Metodo di creazione

Considerando il seguente esempio per spiegare la sintassi di un metodo:

Syntax

public static int methodName(int a, int b) {
   // body
}

Qui,

• public static - modificatore

• int - tipo restituito

• methodName - nome del metodo

• a, b - parametri formali

• int a, int b - elenco dei parametri

La definizione del metodo consiste in un'intestazione del metodo e un corpo del metodo. Lo stesso è mostrato nella seguente sintassi:

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

La sintassi mostrata sopra include:

• modifier - Definisce il tipo di accesso del metodo ed è facoltativo da utilizzare.

• returnType - Il metodo può restituire un valore.

• nameOfMethod- Questo è il nome del metodo. La firma del metodo è costituita dal nome del metodo e dall'elenco dei parametri.

• Parameter List- L'elenco dei parametri, è il tipo, l'ordine e il numero di parametri di un metodo. Questi sono opzionali, il metodo può contenere zero parametri.

• method body - Il corpo del metodo definisce cosa fa il metodo con le istruzioni.

Example

Ecco il codice sorgente del metodo sopra definito chiamato min(). Questo metodo accetta due parametri num1 e num2 e restituisce il massimo tra i due -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Metodo di chiamata

Per utilizzare un metodo, dovrebbe essere chiamato. Ci sono due modi in cui un metodo viene chiamato, cioè il metodo restituisce un valore o non restituisce nulla (nessun valore di ritorno).

Il processo di chiamata del metodo è semplice. Quando un programma richiama un metodo, il controllo del programma viene trasferito al metodo chiamato. Questo metodo chiamato restituisce quindi il controllo al chiamante in due condizioni, quando:

• viene eseguita l'istruzione return.
• raggiunge il metodo terminando la parentesi graffa.

I metodi che restituiscono void sono considerati come chiamate a un'istruzione. Consideriamo un esempio:

System.out.println("This is tutorialspoint.com!");

Il metodo che restituisce il valore può essere compreso dal seguente esempio:

int result = sum(6, 9);

Di seguito è riportato l'esempio per dimostrare come definire un metodo e come chiamarlo -

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Questo produrrà il seguente risultato:

Output

Minimum value = 6

La parola chiave vuota

La parola chiave void ci permette di creare metodi che non restituiscono un valore. Qui, nel seguente esempio stiamo considerando un metodo di metodo voidRankPoints . Questo metodo è un metodo void, che non restituisce alcun valore. La chiamata a un metodo void deve essere un'istruzione, ad esempio methodRankPoints (255.7); . È un'istruzione Java che termina con un punto e virgola come mostrato nell'esempio seguente.

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

Questo produrrà il seguente risultato:

Output

Rank:A1

Passaggio di parametri per valore

Mentre si lavora sotto il processo di chiamata, gli argomenti devono essere passati. Questi dovrebbero essere nello stesso ordine dei rispettivi parametri nella specifica del metodo. I parametri possono essere passati per valore o per riferimento.

Passare parametri per valore significa chiamare un metodo con un parametro. In questo modo, il valore dell'argomento viene passato al parametro.

Example

Il seguente programma mostra un esempio di passaggio di parametri per valore. I valori degli argomenti rimangono gli stessi anche dopo l'invocazione del metodo.

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Questo produrrà il seguente risultato:

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Metodo di sovraccarico

Quando una classe ha due o più metodi con lo stesso nome ma parametri diversi, è noto come sovraccarico del metodo. È diverso dall'override. Nell'override, un metodo ha lo stesso nome, tipo, numero di parametri e così via.

Consideriamo l'esempio discusso in precedenza per trovare i numeri minimi di tipo intero. Se, diciamo, vogliamo trovare il numero minimo di double type. Quindi verrà introdotto il concetto di sovraccarico per creare due o più metodi con lo stesso nome ma parametri differenti.

L'esempio seguente spiega lo stesso:

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Questo produrrà il seguente risultato:

Output

Minimum Value = 6
Minimum Value = 7.3

I metodi di sovraccarico rendono il programma leggibile. Qui, due metodi sono dati con lo stesso nome ma con parametri diversi. Il numero minimo di numeri interi e doppi è il risultato.

Utilizzo degli argomenti della riga di comando

A volte potresti voler passare alcune informazioni a un programma quando lo esegui. Ciò si ottiene passando gli argomenti della riga di comando a main ().

Un argomento della riga di comando è l'informazione che segue direttamente il nome del programma sulla riga di comando quando viene eseguito. Per accedere agli argomenti della riga di comando all'interno di un programma Java è abbastanza semplice. Sono archiviati come stringhe nell'array String passato a main ().

Example

Il seguente programma mostra tutti gli argomenti della riga di comando con cui viene chiamato:

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

Prova a eseguire questo programma come mostrato qui -

$java CommandLine this is a command line 200 -100

Questo produrrà il seguente risultato:

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

La parola chiave this

thisè una parola chiave in Java che viene utilizzata come riferimento all'oggetto della classe corrente, con in un metodo di istanza o un costruttore. Usando questo puoi fare riferimento ai membri di una classe come costruttori, variabili e metodi.

Note- La parola chiave this viene utilizzata solo all'interno di metodi o costruttori di istanze

In generale, la parola chiave this viene utilizzata per:

• Differenziare le variabili di istanza dalle variabili locali se hanno lo stesso nome, all'interno di un costruttore o di un metodo.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

• Chiama un tipo di costruttore (costruttore parametrizzato o predefinito) da un altro in una classe. È noto come invocazione esplicita del costruttore.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

Ecco un esempio che utilizza questa parola chiave per accedere ai membri di una classe. Copia e incolla il seguente programma in un file con il nome,This_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through Parameterized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Questo produrrà il seguente risultato:

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Argomenti variabili (var-args)

JDK 1.5 consente di passare un numero variabile di argomenti dello stesso tipo a un metodo. Il parametro nel metodo è dichiarato come segue:

typeName... parameterName

Nella dichiarazione del metodo si specifica il tipo seguito da puntini di sospensione (...). Un solo parametro di lunghezza variabile può essere specificato in un metodo e questo parametro deve essere l'ultimo parametro. Tutti i parametri regolari devono precederlo.

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

Questo produrrà il seguente risultato:

Output

The max value is 56.5
The max value is 3.0

Il metodo finalize ()

È possibile definire un metodo che verrà chiamato appena prima della distruzione finale di un oggetto da parte del garbage collector. Questo metodo è chiamatofinalize( )e può essere utilizzato per garantire che un oggetto termini in modo pulito.

Ad esempio, potresti usare finalize () per assicurarti che un file aperto di proprietà di quell'oggetto sia chiuso.

Per aggiungere un finalizzatore a una classe, devi semplicemente definire il metodo finalize (). Il runtime Java chiama quel metodo ogni volta che sta per riciclare un oggetto di quella classe.

All'interno del metodo finalize (), specificherai le azioni che devono essere eseguite prima che un oggetto venga distrutto.

Il metodo finalize () ha questa forma generale:

protected void finalize( ) {
   // finalization code here
}

Qui, la parola chiave protected è uno specificatore che impedisce l'accesso a finalize () dal codice definito al di fuori della sua classe.

Ciò significa che non puoi sapere quando o anche se finalize () verrà eseguito. Ad esempio, se il programma termina prima che si verifichi la garbage collection, finalize () non verrà eseguito.

Il pacchetto java.io contiene quasi tutte le classi di cui potresti aver bisogno per eseguire input e output (I / O) in Java. Tutti questi flussi rappresentano una sorgente di input e una destinazione di output. Il flusso nel pacchetto java.io supporta molti dati come primitive, oggetti, caratteri localizzati, ecc.

Stream

Un flusso può essere definito come una sequenza di dati. Esistono due tipi di stream:

• InPutStream - InputStream viene utilizzato per leggere i dati da una sorgente.

• OutPutStream - OutputStream viene utilizzato per scrivere dati su una destinazione.

Java fornisce un supporto forte ma flessibile per l'I / O relativo a file e reti, ma questo tutorial copre funzionalità di base relative a flussi e I / O. Vedremo uno per uno gli esempi più comunemente usati:

Byte Streams

I flussi di byte Java vengono utilizzati per eseguire l'input e l'output di byte a 8 bit. Sebbene ci siano molte classi relative ai flussi di byte, ma le classi utilizzate più di frequente sono,FileInputStream e FileOutputStream. Di seguito è riportato un esempio che utilizza queste due classi per copiare un file di input in un file di output:

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Ora facciamo un file input.txt con il seguente contenuto -

This is test for copy file.

Come passaggio successivo, compila il programma sopra ed eseguilo, il che si tradurrà nella creazione del file output.txt con lo stesso contenuto che abbiamo in input.txt. Quindi mettiamo il codice sopra nel file CopyFile.java e facciamo quanto segue:

$javac CopyFile.java $java CopyFile

Flussi di personaggi

Giava Byte i flussi vengono utilizzati per eseguire input e output di byte a 8 bit, mentre Java Characteri flussi vengono utilizzati per eseguire input e output per Unicode a 16 bit. Sebbene ci siano molte classi relative ai flussi di personaggi, ma le classi utilizzate più di frequente sono,FileReader e FileWriter. Sebbene internamente FileReader utilizzi FileInputStream e FileWriter utilizzi FileOutputStream, ma qui la differenza principale è che FileReader legge due byte alla volta e FileWriter scrive due byte alla volta.

Possiamo riscrivere l'esempio precedente, che utilizza queste due classi per copiare un file di input (con caratteri Unicode) in un file di output -

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Ora facciamo un file input.txt con il seguente contenuto -

This is test for copy file.

Come passaggio successivo, compila il programma sopra ed eseguilo, il che si tradurrà nella creazione del file output.txt con lo stesso contenuto che abbiamo in input.txt. Quindi mettiamo il codice sopra nel file CopyFile.java e facciamo quanto segue:

$javac CopyFile.java $java CopyFile

Stream standard

Tutti i linguaggi di programmazione forniscono supporto per I / O standard in cui il programma dell'utente può ricevere input da una tastiera e quindi produrre un output sullo schermo del computer. Se sei a conoscenza dei linguaggi di programmazione C o C ++, devi essere a conoscenza di tre dispositivi standard STDIN, STDOUT e STDERR. Allo stesso modo, Java fornisce i seguenti tre flussi standard:

• Standard Input - Viene utilizzato per fornire i dati al programma dell'utente e di solito viene utilizzata una tastiera come flusso di input standard e rappresentata come System.in.

• Standard Output - Viene utilizzato per produrre i dati prodotti dal programma dell'utente e di solito lo schermo di un computer viene utilizzato per il flusso di output standard e rappresentato come System.out.

• Standard Error - Viene utilizzato per visualizzare i dati di errore prodotti dal programma dell'utente e di solito lo schermo di un computer viene utilizzato per il flusso di errore standard e rappresentato come System.err.

Di seguito è riportato un semplice programma, che crea InputStreamReader per leggere il flusso di input standard fino a quando l'utente non digita una "q" -

Example

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

Manteniamo il codice sopra nel file ReadConsole.java e proviamo a compilarlo ed eseguirlo come mostrato nel seguente programma. Questo programma continua a leggere e produrre lo stesso carattere finché non premiamo 'q' -

$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Lettura e scrittura di file

Come descritto in precedenza, un flusso può essere definito come una sequenza di dati. IlInputStream viene utilizzato per leggere i dati da una sorgente e il file OutputStream viene utilizzato per scrivere dati in una destinazione.

Ecco una gerarchia di classi per gestire i flussi di input e output.

I due flussi importanti sono FileInputStream e FileOutputStream, che sarà discusso in questo tutorial.

FileInputStream

Questo flusso viene utilizzato per leggere i dati dai file. Gli oggetti possono essere creati utilizzando la parola chiavenew e sono disponibili diversi tipi di costruttori.

Il seguente costruttore prende un nome file come stringa per creare un oggetto flusso di input per leggere il file -

InputStream f = new FileInputStream("C:/java/hello");

Il seguente costruttore prende un oggetto file per creare un oggetto flusso di input per leggere il file. Per prima cosa creiamo un oggetto file usando il metodo File () come segue:

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Una volta che hai l' oggetto InputStream in mano, c'è un elenco di metodi di supporto che possono essere usati per leggere nel flusso o per fare altre operazioni sul flusso.

Sr.No.	Metodo e descrizione
1	public void close() throws IOException{} Questo metodo chiude il flusso di output del file. Rilascia tutte le risorse di sistema associate al file. Genera un'IOException.
2	protected void finalize()throws IOException {} Questo metodo elimina la connessione al file. Assicura che il metodo di chiusura di questo flusso di output del file venga chiamato quando non ci sono più riferimenti a questo flusso. Genera un'IOException.
3	public int read(int r)throws IOException{} Questo metodo legge il byte di dati specificato da InputStream. Restituisce un int. Restituisce il prossimo byte di dati e -1 se è la fine del file.
4	public int read(byte[] r) throws IOException{} Questo metodo legge i byte r.length dal flusso di input in un array. Restituisce il numero totale di byte letti. Se è la fine del file, verrà restituito -1.
5	public int available() throws IOException{} Fornisce il numero di byte che possono essere letti da questo flusso di input di file. Restituisce un int.

Sono disponibili altri importanti flussi di input, per maggiori dettagli è possibile fare riferimento ai seguenti collegamenti:

• ByteArrayInputStream

• DataInputStream

FileOutputStream

FileOutputStream viene utilizzato per creare un file e scrivere dati in esso. Il flusso creerebbe un file, se non esiste già, prima di aprirlo per l'output.

Ecco due costruttori che possono essere usati per creare un oggetto FileOutputStream.

Il seguente costruttore prende un nome file come stringa per creare un oggetto flusso di input per scrivere il file -

OutputStream f = new FileOutputStream("C:/java/hello")

Il costruttore seguente prende un oggetto file per creare un oggetto flusso di output per scrivere il file. Innanzitutto, creiamo un oggetto file utilizzando il metodo File () come segue:

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Una volta che hai in mano l'oggetto OutputStream , c'è un elenco di metodi di supporto, che possono essere usati per scrivere nello stream o per eseguire altre operazioni sullo stream.

Sr.No.	Metodo e descrizione
1	public void close() throws IOException{} Questo metodo chiude il flusso di output del file. Rilascia tutte le risorse di sistema associate al file. Genera un'IOException.
2	protected void finalize()throws IOException {} Questo metodo elimina la connessione al file. Assicura che il metodo di chiusura di questo flusso di output del file venga chiamato quando non ci sono più riferimenti a questo flusso. Genera un'IOException.
3	public void write(int w)throws IOException{} Questo metodo scrive il byte specificato nel flusso di output.
4	public void write(byte[] w) Scrive w.length byte dall'array di byte menzionato in OutputStream.

Sono disponibili altri importanti flussi di output, per maggiori dettagli è possibile fare riferimento ai seguenti collegamenti:

• ByteArrayOutputStream

• DataOutputStream

Example

Di seguito è riportato l'esempio per dimostrare InputStream e OutputStream -

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

Il codice sopra creerebbe il file test.txt e scriverà i numeri dati in formato binario. Lo stesso sarebbe l'output sullo schermo stdout.

Navigazione file e I / O

Ci sono molte altre classi che vorremmo seguire per conoscere le basi della navigazione dei file e dell'I / O.

• Classe di file

• FileReader Class

• Classe FileWriter

Directory in Java

Una directory è un file che può contenere un elenco di altri file e directory. UsateFileoggetto per creare directory, per elencare i file disponibili in una directory. Per i dettagli completi, controlla un elenco di tutti i metodi che puoi chiamare sull'oggetto File e cosa sono correlati alle directory.

Creazione di directory

Ce ne sono due utili File metodi di utilità, che possono essere utilizzati per creare directory -

• Il mkdir( )metodo crea una directory, restituendo true in caso di successo e false in caso di fallimento. L'errore indica che il percorso specificato nell'oggetto File esiste già o che la directory non può essere creata perché l'intero percorso non esiste ancora.

• Il mkdirs() metodo crea sia una directory che tutti i genitori della directory.

L'esempio seguente crea la directory "/ tmp / user / java / bin" -

Example

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

Compila ed esegui il codice precedente per creare "/ tmp / user / java / bin".

Note- Java si occupa automaticamente dei separatori di percorso su UNIX e Windows secondo le convenzioni. Se si utilizza una barra (/) su una versione Windows di Java, il percorso verrà comunque risolto correttamente.

Directory di elenco

Puoi usare list( ) metodo fornito da File oggetto per elencare tutti i file e le directory disponibili in una directory come segue:

Example

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Questo produrrà il seguente risultato in base alle directory e ai file disponibili nel tuo /tmp directory -

Output

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Un'eccezione (o evento eccezionale) è un problema che si verifica durante l'esecuzione di un programma. Quando unException si verifica il normale flusso del programma viene interrotto e il programma / applicazione termina in modo anomalo, il che non è consigliato, pertanto queste eccezioni devono essere gestite.

Un'eccezione può verificarsi per molti motivi diversi. Di seguito sono riportati alcuni scenari in cui si verifica un'eccezione.

• Un utente ha inserito dati non validi.

• Impossibile trovare un file che deve essere aperto.

• Una connessione di rete è stata persa durante le comunicazioni o la JVM ha esaurito la memoria.

Alcune di queste eccezioni sono causate da un errore dell'utente, altre da un errore del programmatore e altre da risorse fisiche che in qualche modo si sono guastate.

Sulla base di questi, abbiamo tre categorie di eccezioni. È necessario comprenderli per sapere come funziona la gestione delle eccezioni in Java.

• Checked exceptions- Un'eccezione verificata è un'eccezione che viene controllata (notificata) dal compilatore in fase di compilazione, queste sono anche chiamate eccezioni in fase di compilazione. Queste eccezioni non possono essere semplicemente ignorate, il programmatore dovrebbe occuparsi di (gestire) queste eccezioni.

Ad esempio, se usi FileReaderclass nel programma per leggere i dati da un file, se il file specificato nel suo costruttore non esiste, si verifica un'eccezione FileNotFoundException e il compilatore richiede al programmatore di gestire l'eccezione.

Esempio

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

Se provi a compilare il programma precedente, otterrai le seguenti eccezioni.

Produzione

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Note - Dal momento che i metodi read() e close() della classe FileReader genera IOException, puoi osservare che il compilatore notifica di gestire IOException, insieme a FileNotFoundException.

• Unchecked exceptions- Un'eccezione non controllata è un'eccezione che si verifica al momento dell'esecuzione. Questi sono anche chiamati comeRuntime Exceptions. Questi includono bug di programmazione, come errori logici o uso improprio di un'API. Le eccezioni di runtime vengono ignorate al momento della compilazione.

Ad esempio, se è stato dichiarato un array di dimensione 5 nel programma, e cercando di chiamare il 6 ^° elemento della matrice poi un ArrayIndexOutOfBoundsExceptionexception si verifica.

Esempio

public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

Se compili ed esegui il programma precedente, otterrai la seguente eccezione.

Produzione

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

• Errors- Non sono affatto eccezioni, ma problemi che sorgono al di fuori del controllo dell'utente o del programmatore. Gli errori vengono generalmente ignorati nel codice perché raramente è possibile eseguire operazioni in merito a un errore. Ad esempio, se si verifica un overflow dello stack, si verificherà un errore. Vengono ignorati anche al momento della compilazione.

Gerarchia delle eccezioni

Tutte le classi di eccezione sono sottotipi della classe java.lang.Exception. La classe di eccezione è una sottoclasse della classe Throwable. Oltre alla classe di eccezione, esiste un'altra sottoclasse chiamata Error che è derivata dalla classe Throwable.

Gli errori sono condizioni anomale che si verificano in caso di guasti gravi, questi non vengono gestiti dai programmi Java. Gli errori vengono generati per indicare gli errori generati dall'ambiente di runtime. Esempio: JVM ha esaurito la memoria. Normalmente, i programmi non possono recuperare da errori.

La classe Exception ha due sottoclassi principali: classe IOException e classe RuntimeException.

Di seguito è riportato un elenco delle eccezioni incorporate di Java selezionate e deselezionate più comuni .

Metodi di eccezioni

Di seguito è riportato l'elenco dei metodi importanti disponibili nella classe Throwable.

Sr.No.	Metodo e descrizione
1	public String getMessage() Restituisce un messaggio dettagliato sull'eccezione che si è verificata. Questo messaggio viene inizializzato nel costruttore Throwable.
2	public Throwable getCause() Restituisce la causa dell'eccezione rappresentata da un oggetto Throwable.
3	public String toString() Restituisce il nome della classe concatenata con il risultato di getMessage ().
4	public void printStackTrace() Stampa il risultato di toString () insieme alla traccia dello stack su System.err, il flusso di output dell'errore.
5	public StackTraceElement [] getStackTrace() Restituisce un array contenente ogni elemento nella traccia dello stack. L'elemento all'indice 0 rappresenta la parte superiore dello stack di chiamate e l'ultimo elemento dell'array rappresenta il metodo in fondo allo stack di chiamate.
6	public Throwable fillInStackTrace() Riempie la traccia dello stack di questo oggetto Throwable con la traccia dello stack corrente, aggiungendosi a qualsiasi informazione precedente nella traccia dello stack.

Catturare le eccezioni

Un metodo rileva un'eccezione utilizzando una combinazione di try e catchparole chiave. Un blocco try / catch viene posizionato attorno al codice che potrebbe generare un'eccezione. Il codice all'interno di un blocco try / catch viene indicato come codice protetto e la sintassi per l'utilizzo di try / catch è la seguente:

Sintassi

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

Il codice soggetto a eccezioni viene inserito nel blocco try. Quando si verifica un'eccezione, l'eccezione che si è verificata viene gestita dal blocco catch ad essa associato. Ogni blocco try dovrebbe essere immediatamente seguito da un blocco catch o infine da un blocco.

Un'istruzione catch implica la dichiarazione del tipo di eccezione che si sta tentando di intercettare. Se si verifica un'eccezione nel codice protetto, viene verificato il blocco (o i blocchi) catch che segue il tentativo. Se il tipo di eccezione che si è verificata è elencato in un blocco catch, l'eccezione viene passata al blocco catch proprio come un argomento viene passato in un parametro del metodo.

Esempio

Quello che segue è un array dichiarato con 2 elementi. Quindi il codice tenta di accedere al 3 ^° elemento dell'array che genera un'eccezione.

// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Questo produrrà il seguente risultato:

Produzione

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Blocchi multipli di cattura

Un blocco try può essere seguito da più blocchi catch. La sintassi per più blocchi catch è la seguente:

Sintassi

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

Le istruzioni precedenti mostrano tre blocchi di cattura, ma puoi averne un numero qualsiasi dopo un singolo tentativo. Se si verifica un'eccezione nel codice protetto, l'eccezione viene lanciata al primo blocco catch nell'elenco. Se il tipo di dati dell'eccezione generata corrisponde a ExceptionType1, viene intercettato lì. In caso contrario, l'eccezione passa alla seconda istruzione catch. Ciò continua fino a quando l'eccezione non viene rilevata o non rientra in tutti i rilevamenti, nel qual caso il metodo corrente interrompe l'esecuzione e l'eccezione viene lanciata al metodo precedente nello stack di chiamate.

Esempio

Ecco un segmento di codice che mostra come utilizzare più istruzioni try / catch.

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

Cattura di più tipi di eccezioni

Poiché Java 7, è possibile gestire più di un'eccezione utilizzando un unico blocco catch, questa funzionalità semplifica il codice. Ecco come lo faresti -

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

Le parole chiave dei lanci / lanci

Se un metodo non gestisce un'eccezione verificata, il metodo deve dichiararlo utilizzando il throwsparola chiave. La parola chiave throws appare alla fine della firma di un metodo.

Puoi lanciare un'eccezione, una nuova istanziata o un'eccezione appena rilevata, utilizzando il throw parola chiave.

Cerca di capire la differenza tra le parole chiave throws e throw, throws viene utilizzato per posticipare la gestione di un'eccezione verificata e throw viene utilizzato per richiamare esplicitamente un'eccezione.

Il metodo seguente dichiara che genera un'eccezione RemoteException:

Esempio

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

Un metodo può dichiarare che genera più di un'eccezione, nel qual caso le eccezioni vengono dichiarate in un elenco separato da virgole. Ad esempio, il metodo seguente dichiara che genera un'eccezione RemoteException e un'eccezione InsufficientFundsException -

Esempio

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

L'ultimo blocco

Il blocco finalmente segue un blocco try o un blocco catch. Un blocco di codice infine viene sempre eseguito, indipendentemente dal verificarsi di un'eccezione.

L'utilizzo di un blocco finalmente consente di eseguire qualsiasi istruzione di tipo cleanup che si desidera eseguire, indipendentemente da ciò che accade nel codice protetto.

Un blocco finalmente appare alla fine dei blocchi di cattura e ha la seguente sintassi:

Sintassi

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

Esempio

public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Questo produrrà il seguente risultato:

Produzione

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Notare quanto segue:

• Una clausola catch non può esistere senza un'istruzione try.

• Non è obbligatorio avere clausole finalmente ogni volta che è presente un blocco try / catch.

• Il blocco try non può essere presente senza la clausola catch o la clausola finalmente.

• Non può essere presente alcun codice tra i blocchi try, catch, latest.

La prova con le risorse

Generalmente, quando usiamo risorse come stream, connessioni, ecc. Dobbiamo chiuderle esplicitamente utilizzando finalmente block. Nel seguente programma, stiamo leggendo i dati da un file utilizzandoFileReader e lo stiamo chiudendo usando finalmente block.

Esempio

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

try-with-resources, indicato anche come automatic resource management, è un nuovo meccanismo di gestione delle eccezioni introdotto in Java 7, che chiude automaticamente le risorse utilizzate all'interno del blocco try catch.

Per utilizzare questa istruzione, è sufficiente dichiarare le risorse richieste tra parentesi e la risorsa creata verrà chiusa automaticamente alla fine del blocco. Di seguito è riportata la sintassi dell'istruzione try-with-resources.

Sintassi

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

Di seguito è riportato il programma che legge i dati in un file utilizzando l'istruzione try-with-resources.

Esempio

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

I seguenti punti devono essere tenuti a mente mentre si lavora con la dichiarazione try-with-resources.

• Per usare una classe con l'istruzione try-with-resources dovrebbe essere implementata AutoCloseable l'interfaccia e il close() metodo di esso viene invocato automaticamente in fase di esecuzione.

• È possibile dichiarare più di una classe nell'istruzione try-with-resources.

• Mentre dichiari più classi nel blocco try dell'istruzione try-with-resources, queste classi vengono chiuse in ordine inverso.

• Tranne la dichiarazione delle risorse tra parentesi, tutto è uguale al normale blocco try / catch di un blocco try.

• La risorsa dichiarata in try viene istanziata appena prima dell'inizio del try-block.

• La risorsa dichiarata nel blocco try viene implicitamente dichiarata come finale.

Eccezioni definite dall'utente

Puoi creare le tue eccezioni in Java. Tieni a mente i seguenti punti quando scrivi le tue classi di eccezioni:

• Tutte le eccezioni devono essere figlio di Throwable.

• Se si desidera scrivere un'eccezione selezionata che viene applicata automaticamente dalla regola Handle o Declare, è necessario estendere la classe Exception.

• Se vuoi scrivere un'eccezione di runtime, devi estendere la classe RuntimeException.

Possiamo definire la nostra classe di eccezione come di seguito:

class MyException extends Exception {
}

Hai solo bisogno di estendere il predefinito Exceptionclass per creare la tua eccezione. Queste sono considerate eccezioni controllate. Il seguenteInsufficientFundsExceptionclass è un'eccezione definita dall'utente che estende la classe Exception, rendendola un'eccezione controllata. Una classe di eccezione è come qualsiasi altra classe, contenente campi e metodi utili.

Esempio

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

Per dimostrare l'utilizzo della nostra eccezione definita dall'utente, la seguente classe CheckingAccount contiene un metododraw () che genera un'eccezione InsufficientFundsException.

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

Il seguente programma BankDemo dimostra di invocare i metodi deposit () edraw () di CheckingAccount.

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

Compila tutti i tre file precedenti ed esegui BankDemo. Questo produrrà il seguente risultato:

Produzione

Depositing $500... Withdrawing $100...

Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

Eccezioni comuni

In Java, è possibile definire due categorie di eccezioni ed errori.

• JVM Exceptions- Queste sono eccezioni / errori che vengono generati esclusivamente o logicamente dalla JVM. Esempi: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.

• Programmatic Exceptions- Queste eccezioni vengono generate esplicitamente dall'applicazione o dai programmatori API. Esempi: IllegalArgumentException, IllegalStateException.

In questo capitolo, discuteremo delle classi interne di Java.

Classi annidate

In Java, proprio come i metodi, anche le variabili di una classe possono avere un'altra classe come membro. La scrittura di una classe all'interno di un'altra è consentita in Java. La classe scritta all'interno è chiamatanested classe la classe che contiene la classe interna è chiamata outer class.

Syntax

La seguente è la sintassi per scrivere una classe annidata. Ecco, la classeOuter_Demo è la classe esterna e la classe Inner_Demo è la classe annidata.

class Outer_Demo {
   class Inner_Demo {
   }
}

Le classi annidate sono divise in due tipi:

• Non-static nested classes - Questi sono i membri non statici di una classe.

• Static nested classes - Questi sono i membri statici di una classe.

Classi interne (classi annidate non statiche)

Le classi interne sono un meccanismo di sicurezza in Java. Sappiamo che una classe non può essere associata al modificatore di accessoprivate, ma se abbiamo la classe come membro di un'altra classe, la classe interna può essere resa privata. E questo viene utilizzato anche per accedere ai membri privati ​​di una classe.

Le classi interne sono di tre tipi a seconda di come e dove le definisci. Sono -

• Classe interna
• Classe interna metodo-locale
• Classe interna anonima

Classe interna

Creare una classe interna è abbastanza semplice. Hai solo bisogno di scrivere una classe all'interno di una classe. A differenza di una classe, una classe interna può essere privata e una volta dichiarata privata una classe interna, non è possibile accedervi da un oggetto esterno alla classe.

Di seguito è riportato il programma per creare una classe interna e accedervi. Nell'esempio fornito, rendiamo privata la classe interna e accediamo alla classe tramite un metodo.

Example

class Outer_Demo {
   int num;
   
   // inner class
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   // Accessing he inner class from the method within
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      // Instantiating the outer class 
      Outer_Demo outer = new Outer_Demo();
      
      // Accessing the display_Inner() method.
      outer.display_Inner();
   }
}

Qui puoi osservarlo Outer_Demo è la classe esterna, Inner_Demo è la classe interiore, display_Inner() è il metodo all'interno del quale stiamo istanziando la classe interna e questo metodo viene richiamato dal main metodo.

Se compili ed esegui il programma sopra, otterrai il seguente risultato:

Output

This is an inner class.

Accesso ai membri privati

Come accennato in precedenza, le classi interne vengono utilizzate anche per accedere ai membri privati ​​di una classe. Supponiamo che una classe abbia membri privati ​​per accedervi. Scrivici una classe interna, restituisci i membri privati ​​da un metodo all'interno della classe interna, diciamo,getValue()e infine da un'altra classe (dalla quale si desidera accedere ai membri privati) chiamare il metodo getValue () della classe interna.

Per istanziare la classe interna, inizialmente devi istanziare la classe esterna. Successivamente, utilizzando l'oggetto della classe esterna, segue il modo in cui è possibile istanziare la classe interna.

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

Il seguente programma mostra come accedere ai membri privati ​​di una classe utilizzando la classe interna.

Example

class Outer_Demo {
   // private variable of the outer class
   private int num = 175;  
   
   // inner class
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      // Instantiating the outer class
      Outer_Demo outer = new Outer_Demo();
      
      // Instantiating the inner class
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

Se compili ed esegui il programma sopra, otterrai il seguente risultato:

Output

This is the getnum method of the inner class: 175

Classe interna metodo-locale

In Java, possiamo scrivere una classe all'interno di un metodo e questo sarà un tipo locale. Come le variabili locali, l'ambito della classe interna è limitato all'interno del metodo.

Una classe interna locale del metodo può essere istanziata solo all'interno del metodo in cui è definita la classe interna. Il seguente programma mostra come utilizzare una classe interna locale al metodo.

Example

public class Outerclass {
   // instance method of the outer class 
   void my_Method() {
      int num = 23;

      // method-local inner class
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } // end of inner class
	   
      // Accessing the inner class
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

Se compili ed esegui il programma sopra, otterrai il seguente risultato:

Output

This is method inner class 23

Classe interna anonima

Una classe interna dichiarata senza un nome di classe è nota come anonymous inner class. In caso di classi interne anonime, le dichiariamo e le istanziamo allo stesso tempo. In genere, vengono utilizzati ogni volta che è necessario sovrascrivere il metodo di una classe o di un'interfaccia. La sintassi di una classe interna anonima è la seguente:

Syntax

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

Il seguente programma mostra come sovrascrivere il metodo di una classe utilizzando la classe interna anonima.

Example

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

Se compili ed esegui il programma sopra, otterrai il seguente risultato:

Output

This is an example of anonymous inner class

Allo stesso modo, puoi sovrascrivere i metodi della classe concreta e dell'interfaccia utilizzando una classe interna anonima.

Classe interna anonima come argomento

Generalmente, se un metodo accetta un oggetto di un'interfaccia, una classe astratta o una classe concreta, allora possiamo implementare l'interfaccia, estendere la classe astratta e passare l'oggetto al metodo. Se è una classe, possiamo passarla direttamente al metodo.

Ma in tutti e tre i casi, puoi passare una classe interna anonima al metodo. Ecco la sintassi per passare una classe interna anonima come argomento del metodo:

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

Il seguente programma mostra come passare una classe interna anonima come argomento del metodo.

Example

// interface
interface Message {
   String greet();
}

public class My_class {
   // method which accepts the object of interface Message
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      // Instantiating the class
      My_class obj = new My_class();

      // Passing an anonymous inner class as an argument
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

Se compili ed esegui il programma sopra, ottieni il seguente risultato:

Output

Hello, This is an example of anonymous inner class as an argument

Classe annidata statica

Una classe interna statica è una classe annidata che è un membro statico della classe esterna. È possibile accedervi senza creare un'istanza della classe esterna, utilizzando altri membri statici. Proprio come i membri statici, una classe annidata statica non ha accesso alle variabili di istanza e ai metodi della classe esterna. La sintassi della classe annidata statica è la seguente:

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

Creare un'istanza di una classe annidata statica è leggermente diverso dall'istanziare una classe interna. Il programma seguente mostra come utilizzare una classe annidata statica.

Example

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

Se compili ed esegui il programma sopra, otterrai il seguente risultato:

Output

This is my nested class

L'ereditarietà può essere definita come il processo in cui una classe acquisisce le proprietà (metodi e campi) di un'altra. Con l'uso dell'ereditarietà le informazioni vengono rese gestibili in ordine gerarchico.

La classe che eredita le proprietà di altri è nota come sottoclasse (classe derivata, classe figlia) e la classe le cui proprietà sono ereditate è nota come superclasse (classe base, classe genitore).

estende la parola chiave

extendsè la parola chiave utilizzata per ereditare le proprietà di una classe. Di seguito è riportata la sintassi della parola chiave extends.

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

Codice d'esempio

Di seguito è riportato un esempio che dimostra l'ereditarietà Java. In questo esempio, puoi osservare due classi, ovvero Calcolo e Mio_Calcolo.

Utilizzando la parola chiave extends, My_Calculation eredita i metodi addition () e Subtraction () della classe Calculation.

Copia e incolla il seguente programma in un file con nome My_Calculation.java

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

Compila ed esegui il codice sopra come mostrato di seguito.

javac My_Calculation.java
java My_Calculation

Dopo aver eseguito il programma, produrrà il seguente risultato:

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

Nel programma dato, quando un oggetto My_Calculationviene creata una classe, una copia del contenuto della superclasse viene creata al suo interno. Ecco perché, utilizzando l'oggetto della sottoclasse, puoi accedere ai membri di una superclasse.

La variabile di riferimento Superclass può contenere l'oggetto sottoclasse, ma usando quella variabile puoi accedere solo ai membri della superclasse, quindi per accedere ai membri di entrambe le classi si consiglia di creare sempre una variabile di riferimento alla sottoclasse.

Se consideri il programma sopra, puoi istanziare la classe come indicato di seguito. Ma usando la variabile di riferimento della superclasse (cal in questo caso) non è possibile chiamare il metodo multiplication(), che appartiene alla sottoclasse My_Calculation.

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- Una sottoclasse eredita tutti i membri (campi, metodi e classi nidificate) dalla sua superclasse. I costruttori non sono membri, quindi non vengono ereditati dalle sottoclassi, ma il costruttore della superclasse può essere richiamato dalla sottoclasse.

La super parola chiave

Il super la parola chiave è simile a thisparola chiave. Di seguito sono riportati gli scenari in cui viene utilizzata la parola chiave super.

• È abituato differentiate the members di superclasse dai membri della sottoclasse, se hanno lo stesso nome.

• È abituato invoke the superclass costruttore dalla sottoclasse.

Differenziare i membri

Se una classe eredita le proprietà di un'altra classe. E se i membri della superclasse hanno gli stessi nomi della sottoclasse, per differenziare queste variabili usiamo la parola chiave super come mostrato di seguito.

super.variable
super.method();

Codice d'esempio

Questa sezione fornisce un programma che dimostra l'utilizzo di super parola chiave.

Nel programma dato, hai due classi e cioè Sub_class e Super_class , entrambe hanno un metodo chiamato display () con differenti implementazioni e una variabile chiamata num con valori differenti. Stiamo invocando il metodo display () di entrambe le classi e stampando il valore della variabile num di entrambe le classi. Qui puoi osservare che abbiamo usato la parola chiave super per differenziare i membri della superclasse dalla sottoclasse.

Copia e incolla il programma in un file con nome Sub_class.java.

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

Compila ed esegui il codice precedente utilizzando la seguente sintassi.

javac Super_Demo
java Super

Eseguendo il programma, otterrai il seguente risultato:

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

Invocare Superclass Constructor

Se una classe eredita le proprietà di un'altra classe, la sottoclasse acquisisce automaticamente il costruttore predefinito della superclasse. Ma se vuoi chiamare un costruttore parametrizzato della superclasse, devi usare la parola chiave super come mostrato di seguito.

super(values);

Codice d'esempio

Il programma fornito in questa sezione mostra come utilizzare la parola chiave super per invocare il costruttore parametrizzato della superclasse. Questo programma contiene una superclasse e una sottoclasse, dove la superclasse contiene un costruttore parametrizzato che accetta un valore intero, e abbiamo usato la parola chiave super per invocare il costruttore parametrizzato della superclasse.

Copia e incolla il seguente programma in un file con il nome Subclass.java

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

Compila ed esegui il codice precedente utilizzando la seguente sintassi.

javac Subclass
java Subclass

Eseguendo il programma, otterrai il seguente risultato:

Output

The value of the variable named age in super class is: 24

Relazione IS-A

IS-A è un modo per dire: questo oggetto è un tipo di quell'oggetto. Vediamo come il fileextends la parola chiave viene utilizzata per ottenere l'ereditarietà.

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

Ora, sulla base dell'esempio precedente, in termini orientati agli oggetti, quanto segue è vero:

• L'animale è la superclasse della classe Mammal.
• Animal è la superclasse della classe Reptile.
• Mammifero e Rettile sono sottoclassi della classe Animale.
• Il cane è la sottoclasse di entrambe le classi Mammiferi e Animali.

Ora, se consideriamo la relazione IS-A, possiamo dire:

• Il mammifero è un animale
• Il rettile è un animale
• Il cane è un mammifero
• Quindi: anche il cane è un animale

Con l'uso della parola chiave extends, le sottoclassi potranno ereditare tutte le proprietà della superclasse tranne le proprietà private della superclasse.

Possiamo assicurare che Mammal è effettivamente un Animale con l'uso dell'operatore di istanza.

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Questo produrrà il seguente risultato:

Output

true
true
true

Poiché abbiamo una buona conoscenza di extends parola chiave, esaminiamo come la implements la parola chiave viene utilizzata per ottenere la relazione IS-A.

In generale, il implementsla parola chiave viene utilizzata con le classi per ereditare le proprietà di un'interfaccia. Le interfacce non possono mai essere estese da una classe.

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

L'istanza della parola chiave

Usiamo il file instanceof operatore per verificare se il mammifero è effettivamente un animale e il cane è effettivamente un animale.

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Questo produrrà il seguente risultato:

Output

true
true
true

Relazione HAS-A

Queste relazioni si basano principalmente sull'utilizzo. Questo determina se una certa classeHAS-Acerta cosa. Questa relazione aiuta a ridurre la duplicazione del codice e i bug.

Vediamo un esempio:

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

Questo mostra quella classe Van HAS-A Speed. Avendo una classe separata per Speed, non dobbiamo inserire l'intero codice che appartiene a speed all'interno della classe Van, il che rende possibile riutilizzare la classe Speed ​​in più applicazioni.

Nella funzionalità orientata agli oggetti, gli utenti non devono preoccuparsi di quale oggetto sta facendo il lavoro reale. Per ottenere ciò, la classe Van nasconde i dettagli di implementazione agli utenti della classe Van. Quindi, in pratica, ciò che accade è che gli utenti chiedono alla classe Van di eseguire una determinata azione e la classe Van farà il lavoro da sola o chiederà a un'altra classe di eseguire l'azione.

Tipi di ereditarietà

Esistono vari tipi di ereditarietà come illustrato di seguito.

Un fatto molto importante da ricordare è che Java non supporta l'ereditarietà multipla. Ciò significa che una classe non può estendere più di una classe. Quindi seguire è illegale -

Example

public class extends Animal, Mammal{}

Tuttavia, una classe può implementare una o più interfacce, il che ha aiutato Java a sbarazzarsi dell'impossibilità di ereditarietà multipla.

Nel capitolo precedente abbiamo parlato di superclassi e sottoclassi. Se una classe eredita un metodo dalla sua superclasse, c'è la possibilità di sovrascrivere il metodo a condizione che non sia contrassegnato come finale.

Il vantaggio dell'override è: capacità di definire un comportamento specifico per il tipo di sottoclasse, il che significa che una sottoclasse può implementare un metodo di classe padre in base ai suoi requisiti.

In termini orientati agli oggetti, sovrascrivere significa sovrascrivere la funzionalità di un metodo esistente.

Esempio

Vediamo un esempio.

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Questo produrrà il seguente risultato:

Produzione

Animals can move
Dogs can walk and run

Nell'esempio sopra, puoi vederlo anche se bè un tipo di animale che esegue il metodo di spostamento nella classe Dog. Il motivo è: in fase di compilazione, il controllo viene effettuato sul tipo di riferimento. Tuttavia, durante il runtime, JVM individua il tipo di oggetto ed eseguirà il metodo che appartiene a quel particolare oggetto.

Pertanto, nell'esempio precedente, il programma verrà compilato correttamente poiché la classe Animal ha il metodo move. Quindi, in fase di esecuzione, esegue il metodo specifico per quell'oggetto.

Considera il seguente esempio:

Esempio

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

Questo produrrà il seguente risultato:

Produzione

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

Questo programma genererà un errore in fase di compilazione poiché il tipo di riferimento di b Animal non ha un metodo con il nome di bark.

Regole per l'override del metodo

• La lista degli argomenti dovrebbe essere esattamente la stessa di quella del metodo sovrascritto.

• Il tipo restituito dovrebbe essere lo stesso o un sottotipo del tipo restituito dichiarato nel metodo originale sostituito nella superclasse.

• Il livello di accesso non può essere più restrittivo del livello di accesso del metodo sostituito. Ad esempio: se il metodo della superclasse è dichiarato pubblico, il metodo sovrascritto nella sottoclasse non può essere privato o protetto.

• I metodi di istanza possono essere sovrascritti solo se ereditati dalla sottoclasse.

• Un metodo dichiarato final non può essere sovrascritto.

• Un metodo dichiarato statico non può essere sovrascritto ma può essere nuovamente dichiarato.

• Se un metodo non può essere ereditato, non può essere sovrascritto.

• Una sottoclasse all'interno dello stesso pacchetto della superclasse dell'istanza può sovrascrivere qualsiasi metodo della superclasse non dichiarato privato o finale.

• Una sottoclasse in un pacchetto diverso può solo sovrascrivere i metodi non finali dichiarati pubblici o protetti.

• Un metodo override può generare eccezioni deselezionate, indipendentemente dal fatto che il metodo sottoposto a override generi eccezioni o meno. Tuttavia, il metodo sovrascritto non deve generare eccezioni verificate nuove o più ampie di quelle dichiarate dal metodo sostituito. Il metodo override può generare eccezioni più strette o meno rispetto al metodo sottoposto a override.

• I costruttori non possono essere sovrascritti.

Utilizzando la parola chiave super

Quando si richiama una versione superclasse di un metodo sovrascritto, il file super viene utilizzata la parola chiave.

Esempio

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

Questo produrrà il seguente risultato:

Produzione

Animals can move
Dogs can walk and run

Il polimorfismo è la capacità di un oggetto di assumere molte forme. L'uso più comune del polimorfismo in OOP si verifica quando un riferimento alla classe padre viene utilizzato per fare riferimento a un oggetto classe figlio.

Qualsiasi oggetto Java che può superare più di un test IS-A è considerato polimorfico. In Java, tutti gli oggetti Java sono polimorfici poiché qualsiasi oggetto supererà il test IS-A per il proprio tipo e per la classe Object.

È importante sapere che l'unico modo possibile per accedere a un oggetto è attraverso una variabile di riferimento. Una variabile di riferimento può essere di un solo tipo. Una volta dichiarato, il tipo di una variabile di riferimento non può essere modificato.

La variabile di riferimento può essere riassegnata ad altri oggetti a condizione che non sia dichiarata final. Il tipo della variabile di riferimento determinerebbe i metodi che può invocare sull'oggetto.

Una variabile di riferimento può fare riferimento a qualsiasi oggetto del suo tipo dichiarato oa qualsiasi sottotipo del suo tipo dichiarato. Una variabile di riferimento può essere dichiarata come classe o tipo di interfaccia.

Esempio

Vediamo un esempio.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Ora, la classe Deer è considerata polimorfa poiché ha ereditarietà multipla. Quanto segue è vero per gli esempi precedenti:

• Un cervo è un animale
• Un cervo è vegetariano
• Un cervo è un cervo
• Un cervo è un oggetto

Quando applichiamo i fatti della variabile di riferimento a un riferimento a un oggetto Deer, le seguenti dichiarazioni sono legali:

Esempio

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Tutte le variabili di riferimento d, a, v, o si riferiscono allo stesso oggetto Deer nell'heap.

Metodi virtuali

In questa sezione, ti mostrerò come il comportamento dei metodi sovrascritti in Java ti consente di sfruttare il polimorfismo durante la progettazione delle tue classi.

Abbiamo già discusso l'override del metodo, in cui una classe figlia può sovrascrivere un metodo nel suo genitore. Un metodo sovrascritto è essenzialmente nascosto nella classe genitore e non viene richiamato a meno che la classe figlia non utilizzi la parola chiave super all'interno del metodo sovrascrivente.

Esempio

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Supponiamo ora di estendere la classe Employee come segue:

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Ora studi attentamente il seguente programma e cerchi di determinarne l'output:

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Questo produrrà il seguente risultato:

Produzione

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Qui, istanziamo due oggetti Salary. Uno che utilizza un riferimento di stipendiose l'altro utilizzando un riferimento Employee e.

Mentre invoca s.mailCheck () , il compilatore vede mailCheck () nella classe Salary in fase di compilazione e la JVM richiama mailCheck () nella classe Salary in fase di esecuzione.

mailCheck () attivo e è abbastanza diverso perché eè un riferimento per i dipendenti. Quando il compilatore vede e.mailCheck () , il compilatore vede il metodo mailCheck () nella classe Employee.

Qui, in fase di compilazione, il compilatore ha utilizzato mailCheck () in Employee per convalidare questa istruzione. In fase di esecuzione, tuttavia, la JVM richiama mailCheck () nella classe Salary.

Questo comportamento viene definito invocazione di metodi virtuali e questi metodi vengono definiti metodi virtuali. Un metodo sottoposto a override viene richiamato in fase di esecuzione, indipendentemente dal tipo di dati di riferimento utilizzato nel codice sorgente in fase di compilazione.

Come da dizionario, abstractionè la qualità di trattare le idee piuttosto che gli eventi. Ad esempio, se si considera il caso della posta elettronica, dettagli complessi come ciò che accade non appena si invia un'e-mail, il protocollo utilizzato dal proprio server di posta elettronica vengono nascosti all'utente. Pertanto, per inviare un'e-mail è sufficiente digitare il contenuto, menzionare l'indirizzo del destinatario e fare clic su invia.

Allo stesso modo nella programmazione orientata agli oggetti, l'astrazione è un processo di nascondere i dettagli di implementazione all'utente, solo la funzionalità verrà fornita all'utente. In altre parole, l'utente avrà le informazioni su ciò che fa l'oggetto invece di come lo fa.

In Java, l'astrazione si ottiene utilizzando classi e interfacce astratte.

Classe astratta

Una classe che contiene il file abstract la parola chiave nella sua dichiarazione è nota come classe astratta.

• Le classi astratte possono contenere o meno metodi astratti , cioè metodi senza corpo (public void get ();)

• Ma, se una classe ha almeno un metodo astratto, la classe must essere dichiarato astratto.

• Se una classe viene dichiarata astratta, non può essere istanziata.

• Per usare una classe astratta, devi ereditarla da un'altra classe, fornire implementazioni ai metodi astratti in essa contenuti.

• Se erediti una classe astratta, devi fornire implementazioni a tutti i metodi astratti in essa contenuti.

Esempio

Questa sezione fornisce un esempio della classe astratta. Per creare una classe astratta, usa semplicemente il fileabstract parola chiave prima della parola chiave della classe, nella dichiarazione della classe.

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

È possibile osservare che, ad eccezione dei metodi astratti, la classe Employee è la stessa della normale classe in Java. La classe è ora astratta, ma ha ancora tre campi, sette metodi e un costruttore.

Ora puoi provare a creare un'istanza della classe Employee nel modo seguente:

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Quando compili la classe sopra, ti dà il seguente errore:

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Ereditare la classe astratta

Possiamo ereditare le proprietà della classe Employee proprio come la classe concreta nel modo seguente:

Esempio

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Qui, non è possibile creare un'istanza della classe Employee, ma è possibile creare un'istanza della classe Salary e utilizzando questa istanza è possibile accedere a tutti i tre campi e sette metodi della classe Employee come mostrato di seguito.

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Questo produce il seguente risultato:

Produzione

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Metodi astratti

Se si desidera che una classe contenga un particolare metodo ma si desidera che l'effettiva implementazione di quel metodo sia determinata dalle classi figlie, è possibile dichiarare il metodo nella classe genitore come astratto.

• abstract viene utilizzata per dichiarare il metodo come astratto.

• Devi posizionare il file abstract parola chiave prima del nome del metodo nella dichiarazione del metodo.

• Un metodo astratto contiene una firma del metodo, ma nessun corpo del metodo.

• Invece delle parentesi graffe, un metodo astratto avrà un punto e virgola (;) alla fine.

Di seguito è riportato un esempio del metodo astratto.

Esempio

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

Dichiarare un metodo come astratto ha due conseguenze:

• La classe che lo contiene deve essere dichiarata astratta.

• Qualsiasi classe che eredita la classe corrente deve sovrascrivere il metodo astratto o dichiararsi astratta.

Note- Alla fine, una classe discendente deve implementare il metodo astratto; altrimenti, avresti una gerarchia di classi astratte che non possono essere istanziate.

Supponiamo che la classe Salary erediti la classe Employee, quindi dovrebbe implementare l'estensione computePay() metodo come mostrato di seguito -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Encapsulationè uno dei quattro concetti fondamentali dell'OOP. Gli altri tre sono ereditarietà, polimorfismo e astrazione.

L'incapsulamento in Java è un meccanismo di avvolgimento dei dati (variabili) e del codice che agisce sui dati (metodi) insieme come una singola unità. Nell'incapsulamento, le variabili di una classe saranno nascoste alle altre classi e sarà possibile accedervi solo tramite i metodi della loro classe corrente. Pertanto, è anche noto comedata hiding.

Per ottenere l'incapsulamento in Java -

• Dichiarare le variabili di una classe come private.

• Fornire metodi setter e getter pubblici per modificare e visualizzare i valori delle variabili.

Esempio

Di seguito è riportato un esempio che dimostra come ottenere l'incapsulamento in Java:

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

I metodi pubblici setXXX () e getXXX () sono i punti di accesso delle variabili di istanza della classe EncapTest. Normalmente, questi metodi sono indicati come getter e setter. Pertanto, qualsiasi classe che desideri accedere alle variabili dovrebbe accedervi tramite questi getter e setter.

È possibile accedere alle variabili della classe EncapTest utilizzando il seguente programma:

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

Questo produrrà il seguente risultato:

Produzione

Name : James Age : 20

Vantaggi dell'incapsulamento

• I campi di una classe possono essere di sola lettura o di sola scrittura.

• Una classe può avere il controllo totale su ciò che è memorizzato nei suoi campi.

Un'interfaccia è un tipo di riferimento in Java. È simile alla classe. È una raccolta di metodi astratti. Una classe implementa un'interfaccia, ereditando così i metodi astratti dell'interfaccia.

Insieme ai metodi astratti, un'interfaccia può anche contenere costanti, metodi predefiniti, metodi statici e tipi annidati. I corpi dei metodi esistono solo per metodi predefiniti e metodi statici.

La scrittura di un'interfaccia è simile alla scrittura di una classe. Ma una classe descrive gli attributi e i comportamenti di un oggetto. E un'interfaccia contiene comportamenti implementati da una classe.

A meno che la classe che implementa l'interfaccia non sia astratta, tutti i metodi dell'interfaccia devono essere definiti nella classe.

Un'interfaccia è simile a una classe nei seguenti modi:

• Un'interfaccia può contenere un numero qualsiasi di metodi.

• Un'interfaccia è scritta in un file con estensione .java estensione, con il nome dell'interfaccia che corrisponde al nome del file.

• Il codice byte di un'interfaccia appare in un file .class file.

• Le interfacce vengono visualizzate nei pacchetti e il file bytecode corrispondente deve trovarsi in una struttura di directory che corrisponda al nome del pacchetto.

Tuttavia, un'interfaccia è diversa da una classe in diversi modi, tra cui:

• Non è possibile creare un'istanza di un'interfaccia.

• Un'interfaccia non contiene alcun costruttore.

• Tutti i metodi in un'interfaccia sono astratti.

• Un'interfaccia non può contenere campi istanza. Gli unici campi che possono apparire in un'interfaccia devono essere dichiarati sia statici che finali.

• Un'interfaccia non è estesa da una classe; è implementato da una classe.

• Un'interfaccia può estendere più interfacce.

Dichiarazione di interfacce

Il interfaceparola chiave viene utilizzata per dichiarare un'interfaccia. Ecco un semplice esempio per dichiarare un'interfaccia:

Esempio

Di seguito è riportato un esempio di interfaccia:

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

Le interfacce hanno le seguenti proprietà:

• Un'interfaccia è implicitamente astratta. Non è necessario utilizzare l'estensioneabstract parola chiave durante la dichiarazione di un'interfaccia.

• Ogni metodo in un'interfaccia è anche implicitamente astratto, quindi la parola chiave abstract non è necessaria.

• I metodi in un'interfaccia sono implicitamente pubblici.

Esempio

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

Implementazione delle interfacce

Quando una classe implementa un'interfaccia, puoi pensare alla classe come alla firma di un contratto, che accetta di eseguire i comportamenti specifici dell'interfaccia. Se una classe non esegue tutti i comportamenti dell'interfaccia, la classe deve dichiararsi astratta.

Una classe utilizza l'estensione implementsparola chiave per implementare un'interfaccia. La parola chiave implements appare nella dichiarazione della classe che segue la parte extends della dichiarazione.

Esempio

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Questo produrrà il seguente risultato:

Produzione

Mammal eats
Mammal travels

Quando si sovrascrivono i metodi definiti nelle interfacce, ci sono diverse regole da seguire:

• Le eccezioni verificate non dovrebbero essere dichiarate su metodi di implementazione diversi da quelli dichiarati dal metodo di interfaccia o da sottoclassi di quelli dichiarati dal metodo di interfaccia.

• La firma del metodo di interfaccia e lo stesso tipo o sottotipo restituito devono essere mantenuti quando si sovrascrivono i metodi.

• Una classe di implementazione stessa può essere astratta e, in tal caso, i metodi di interfaccia non devono essere implementati.

Quando l'implementazione si interfaccia, ci sono diverse regole:

• Una classe può implementare più di un'interfaccia alla volta.

• Una classe può estendere solo una classe, ma implementare molte interfacce.

• Un'interfaccia può estendere un'altra interfaccia, in modo simile a come una classe può estendere un'altra classe.

Estensione delle interfacce

Un'interfaccia può estendere un'altra interfaccia nello stesso modo in cui una classe può estendere un'altra classe. Ilextends la parola chiave viene utilizzata per estendere un'interfaccia e l'interfaccia figlio eredita i metodi dell'interfaccia padre.

La seguente interfaccia Sports è estesa dalle interfacce Hockey e Football.

Esempio

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

L'interfaccia Hockey ha quattro metodi, ma ne eredita due da Sports; quindi, una classe che implementa Hockey deve implementare tutti e sei i metodi. Allo stesso modo, una classe che implementa Football deve definire i tre metodi di Football e i due metodi di Sports.

Estensione di più interfacce

Una classe Java può estendere solo una classe genitore. L'ereditarietà multipla non è consentita. Le interfacce non sono classi, tuttavia, e un'interfaccia può estendere più di un'interfaccia padre.

La parola chiave extends viene utilizzata una volta e le interfacce padre vengono dichiarate in un elenco separato da virgole.

Ad esempio, se l'interfaccia Hockey estendesse sia Sport che Eventi, verrebbe dichiarata come:

Esempio

public interface Hockey extends Sports, Event

Interfacce di codifica

L'utilizzo più comune dell'estensione delle interfacce si verifica quando l'interfaccia padre non contiene alcun metodo. Ad esempio, l'interfaccia MouseListener nel pacchetto java.awt.event ha esteso java.util.EventListener, che è definito come -

Esempio

package java.util;
public interface EventListener
{}

Un'interfaccia senza metodi al suo interno viene indicata come un file tagginginterfaccia. Ci sono due scopi di progettazione di base per la codifica delle interfacce:

Creates a common parent- Come con l'interfaccia EventListener, che è estesa da dozzine di altre interfacce nell'API Java, è possibile utilizzare un'interfaccia di tagging per creare un genitore comune in un gruppo di interfacce. Ad esempio, quando un'interfaccia estende EventListener, la JVM sa che questa particolare interfaccia verrà utilizzata in uno scenario di delega degli eventi.

Adds a data type to a class- Questa situazione è da dove viene il termine, tagging. Una classe che implementa un'interfaccia di tagging non ha bisogno di definire alcun metodo (poiché l'interfaccia non ne ha), ma la classe diventa un tipo di interfaccia attraverso il polimorfismo.

I pacchetti vengono utilizzati in Java per prevenire conflitti di denominazione, per controllare l'accesso, per rendere più facile la ricerca / localizzazione e l'utilizzo di classi, interfacce, enumerazioni e annotazioni, ecc.

UN Package può essere definito come un raggruppamento di tipi correlati (classi, interfacce, enumerazioni e annotazioni) che forniscono protezione dell'accesso e gestione dello spazio dei nomi.

Alcuni dei pacchetti esistenti in Java sono:

• java.lang - raggruppa le classi fondamentali

• java.io - classi per input, funzioni di output sono raggruppate in questo pacchetto

I programmatori possono definire i propri pacchetti per raggruppare un gruppo di classi / interfacce, ecc. È buona pratica raggruppare le classi correlate implementate in modo che un programmatore possa facilmente determinare che le classi, le interfacce, le enumerazioni e le annotazioni sono correlate.

Poiché il pacchetto crea un nuovo spazio dei nomi, non ci saranno conflitti di nome con i nomi in altri pacchetti. Utilizzando i pacchetti, è più facile fornire il controllo degli accessi ed è anche più facile individuare le classi correlate.

Creazione di un pacchetto

Durante la creazione di un pacchetto, dovresti scegliere un nome per il pacchetto e includere un file package insieme a quel nome all'inizio di ogni file sorgente che contiene le classi, le interfacce, le enumerazioni e i tipi di annotazioni che si desidera includere nel pacchetto.

La dichiarazione del pacchetto dovrebbe essere la prima riga del file sorgente. Può esserci una sola istruzione del pacchetto in ogni file di origine e si applica a tutti i tipi nel file.

Se un'istruzione del pacchetto non viene utilizzata, la classe, le interfacce, le enumerazioni e i tipi di annotazione verranno inseriti nel pacchetto predefinito corrente.

Per compilare i programmi Java con le istruzioni del pacchetto, è necessario utilizzare l'opzione -d come mostrato di seguito.

javac -d Destination_folder file_name.java

Quindi una cartella con il nome del pacchetto specificato viene creata nella destinazione specificata e i file di classe compilati verranno inseriti in quella cartella.

Esempio

Vediamo un esempio che crea un pacchetto chiamato animals. È buona norma utilizzare nomi di pacchetti con lettere minuscole per evitare conflitti con i nomi di classi e interfacce.

Il seguente esempio di pacchetto contiene un'interfaccia denominata animali -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Ora, implementiamo l'interfaccia sopra nello stesso pacchetto di animali :

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Ora compila i file java come mostrato di seguito -

$ javac -d . Animal.java $ javac -d . MammalInt.java

Ora un pacchetto / cartella con il nome animals verrà creato nella directory corrente e questi file di classe verranno inseriti in essa come mostrato di seguito.

È possibile eseguire il file di classe all'interno del pacchetto e ottenere il risultato come mostrato di seguito.

Mammal eats
Mammal travels

La parola chiave di importazione

Se una classe desidera utilizzare un'altra classe nello stesso pacchetto, non è necessario utilizzare il nome del pacchetto. Le classi nello stesso pacchetto si trovano senza alcuna sintassi speciale.

Esempio

Qui, una classe denominata Boss viene aggiunta al pacchetto del libro paga che contiene già Employee. Il Boss può quindi fare riferimento alla classe Employee senza utilizzare il prefisso del libro paga, come dimostrato dalla seguente classe Boss.

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

Cosa succede se la classe Employee non è nel pacchetto del libro paga? La classe Boss deve quindi utilizzare una delle seguenti tecniche per fare riferimento a una classe in un pacchetto diverso.

• È possibile utilizzare il nome completo della classe. Ad esempio:

payroll.Employee

• Il pacchetto può essere importato utilizzando la parola chiave import e il carattere jolly (*). Ad esempio:

import payroll.*;

• La classe stessa può essere importata utilizzando la parola chiave import. Ad esempio:

import payroll.Employee;

Note- Un file di classe può contenere un numero qualsiasi di istruzioni di importazione. Le istruzioni di importazione devono apparire dopo l'istruzione del pacchetto e prima della dichiarazione della classe.

La struttura delle directory dei pacchetti

Due risultati principali si verificano quando una classe viene inserita in un pacchetto:

• Il nome del pacchetto diventa una parte del nome della classe, come abbiamo appena discusso nella sezione precedente.

• Il nome del pacchetto deve corrispondere alla struttura della directory in cui risiede il bytecode corrispondente.

Ecco un modo semplice per gestire i tuoi file in Java:

Inserisci il codice sorgente per un tipo di classe, interfaccia, enumerazione o annotazione in un file di testo il cui nome è il nome semplice del tipo e la cui estensione è .java.

Ad esempio:

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Ora, metti il ​​file sorgente in una directory il cui nome riflette il nome del pacchetto a cui appartiene la classe -

....\vehicle\Car.java

Ora, il nome della classe e il percorso qualificati sarebbero i seguenti:

• Nome classe → veicolo Auto
• Nome percorso → veicolo \ Car.java (in Windows)

In generale, un'azienda utilizza il nome di dominio Internet invertito per i nomi dei pacchetti.

Example- Il nome di dominio Internet di un'azienda è apple.com, quindi tutti i nomi dei suoi pacchetti inizieranno con com.apple. Ogni componente del nome del pacchetto corrisponde a una sottodirectory.

Example - L'azienda aveva un pacchetto com.apple.computers che conteneva un file sorgente Dell.java, sarebbe stato contenuto in una serie di sottodirectory come questa -

....\com\apple\computers\Dell.java

Al momento della compilazione, il compilatore crea un file di output diverso per ogni classe, interfaccia ed enumerazione definita in esso. Il nome di base del file di output è il nome del tipo e la sua estensione è.class.

Ad esempio:

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Ora, compila questo file come segue usando l'opzione -d -

$javac -d . Dell.java

I file verranno compilati come segue:

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Puoi importare tutte le classi o interfacce definite in \ com \ apple \ computers \ come segue:

import com.apple.computers.*;

Come i file sorgente .java, i file .class compilati dovrebbero trovarsi in una serie di directory che riflettono il nome del pacchetto. Tuttavia, il percorso dei file .class non deve essere lo stesso del percorso dei file di origine .java. Puoi organizzare separatamente le directory di origine e di classe, come:

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

In questo modo, è possibile dare accesso alla directory delle classi ad altri programmatori senza rivelare i propri sorgenti. È inoltre necessario gestire i file di origine e di classe in questo modo in modo che il compilatore e la Java Virtual Machine (JVM) possano trovare tutti i tipi utilizzati dal programma.

Il percorso completo della directory delle classi, <path-two> \ classes, è chiamato percorso della classe ed è impostato con la variabile di sistema CLASSPATH. Sia il compilatore che la JVM costruiscono il percorso dei file .class aggiungendo il nome del pacchetto al percorso della classe.

Diciamo che <path-two> \ classes è il percorso della classe e il nome del pacchetto è com.apple.computers, quindi il compilatore e JVM cercheranno i file .class in <path-two> \ classes \ com \ apple \ computers.

Un percorso di classe può includere diversi percorsi. Più percorsi devono essere separati da un punto e virgola (Windows) o da due punti (Unix). Per impostazione predefinita, il compilatore e la JVM cercano la directory corrente e il file JAR contenente le classi della piattaforma Java in modo che queste directory siano automaticamente nel percorso classe.

Imposta la variabile di sistema CLASSPATH

Per visualizzare la variabile CLASSPATH corrente, utilizzare i seguenti comandi in Windows e UNIX (Bourne shell):

• In Windows → C: \> imposta CLASSPATH
• In UNIX →% echo $ CLASSPATH

Per eliminare il contenuto corrente della variabile CLASSPATH, utilizzare -

• In Windows → C: \> imposta CLASSPATH =
• In UNIX →% unset CLASSPATH; esporta CLASSPATH

Per impostare la variabile CLASSPATH -

• In Windows → imposta CLASSPATH = C: \ users \ jack \ java \ classes
• In UNIX →% CLASSPATH = / home / jack / java / classes; esporta CLASSPATH

Le strutture dati fornite dal pacchetto di utilità Java sono molto potenti e svolgono un'ampia gamma di funzioni. Queste strutture dati sono costituite dalla seguente interfaccia e classi:

• Enumeration
• BitSet
• Vector
• Stack
• Dictionary
• Hashtable
• Properties

Tutte queste classi sono ora legacy e Java-2 ha introdotto un nuovo framework chiamato Collections Framework, che verrà discusso nel prossimo capitolo. -

L'enumerazione

L'interfaccia Enumeration non è di per sé una struttura di dati, ma è molto importante nel contesto di altre strutture di dati. L'interfaccia Enumeration definisce un mezzo per recuperare gli elementi successivi da una struttura dati.

Ad esempio, Enumeration definisce un metodo chiamato nextElement che viene utilizzato per ottenere l'elemento successivo in una struttura dati che contiene più elementi.

Per avere maggiori dettagli su questa interfaccia, seleziona The Enumeration .

Il BitSet

La classe BitSet implementa un gruppo di bit o flag che possono essere impostati e cancellati individualmente.

Questa classe è molto utile nei casi in cui è necessario tenere il passo con un insieme di valori booleani; basta assegnare un bit a ciascun valore e impostarlo o cancellarlo come appropriato.

Per maggiori dettagli su questa classe, controlla The BitSet .

Il vettore

La classe Vector è simile a un array Java tradizionale, tranne per il fatto che può crescere se necessario per accogliere nuovi elementi.

Come un array, è possibile accedere agli elementi di un oggetto Vector tramite un indice nel vettore.

La cosa bella dell'utilizzo della classe Vector è che non devi preoccuparti di impostarla su una dimensione specifica al momento della creazione; si restringe e cresce automaticamente quando necessario.

Per maggiori dettagli su questa classe, controlla The Vector .

Lo Stack

La classe Stack implementa una pila di elementi LIFO (last-in-first-out).

Puoi pensare a una pila letteralmente come una pila verticale di oggetti; quando aggiungi un nuovo elemento, viene impilato sugli altri.

Quando si estrae un elemento dalla pila, viene fuori dalla parte superiore. In altre parole, l'ultimo elemento che hai aggiunto alla pila è il primo a tornare indietro.

Per maggiori dettagli su questa classe, controlla The Stack .

Il dizionario

La classe Dictionary è una classe astratta che definisce una struttura di dati per mappare le chiavi ai valori.

Ciò è utile nei casi in cui si desidera essere in grado di accedere ai dati tramite una chiave particolare anziché un indice intero.

Poiché la classe Dictionary è astratta, fornisce solo il framework per una struttura dati mappata con chiavi anziché un'implementazione specifica.

Per maggiori dettagli su questa classe, controlla il dizionario .

Hashtable

La classe Hashtable fornisce un mezzo per organizzare i dati in base a una struttura chiave definita dall'utente.

Ad esempio, in una tabella hash di un elenco di indirizzi è possibile memorizzare e ordinare i dati in base a una chiave come il codice postale anziché al nome di una persona.

Il significato specifico delle chiavi rispetto alle tabelle hash dipende totalmente dall'utilizzo della tabella hash e dai dati in essa contenuti.

Per maggiori dettagli su questa classe, controlla The Hashtable .

Le proprietà

Properties è una sottoclasse di Hashtable. Viene utilizzato per mantenere elenchi di valori in cui la chiave è una stringa e anche il valore è una stringa.

La classe Properties viene utilizzata da molte altre classi Java. Ad esempio, è il tipo di oggetto restituito da System.getProperties () quando si ottengono i valori ambientali.

Per maggiori dettagli su questa classe, controlla le proprietà .

Prima di Java 2, Java forniva classi ad hoc come Dictionary, Vector, Stack, e Propertiesper memorizzare e manipolare gruppi di oggetti. Sebbene queste classi fossero piuttosto utili, mancavano di un tema centrale e unificante. Pertanto, il modo in cui hai utilizzato Vector era diverso dal modo in cui hai utilizzato Proprietà.

Il framework delle collezioni è stato progettato per soddisfare diversi obiettivi, come:

• Il framework doveva essere ad alte prestazioni. Le implementazioni per le raccolte fondamentali (array dinamici, elenchi collegati, alberi e tabelle hash) dovevano essere altamente efficienti.

• Il framework doveva consentire a diversi tipi di raccolte di funzionare in modo simile e con un alto grado di interoperabilità.

• Il framework doveva estendere e / o adattare facilmente una raccolta.

A tal fine, l'intero framework delle collezioni è progettato attorno a una serie di interfacce standard. Diverse implementazioni standard comeLinkedList, HashSet, e TreeSet, di queste interfacce sono fornite che puoi usare così com'è e puoi anche implementare la tua raccolta, se lo desideri.

Un framework di raccolte è un'architettura unificata per rappresentare e manipolare le raccolte. Tutti i framework delle raccolte contengono quanto segue:

• Interfaces- Questi sono tipi di dati astratti che rappresentano le raccolte. Le interfacce consentono di manipolare le raccolte indipendentemente dai dettagli della loro rappresentazione. Nei linguaggi orientati agli oggetti, le interfacce generalmente formano una gerarchia.

• Implementations, i.e., Classes- Queste sono le implementazioni concrete delle interfacce di raccolta. In sostanza, sono strutture dati riutilizzabili.

• Algorithms- Questi sono i metodi che eseguono calcoli utili, come la ricerca e l'ordinamento, sugli oggetti che implementano le interfacce di raccolta. Si dice che gli algoritmi siano polimorfici: ovvero, lo stesso metodo può essere utilizzato su molte diverse implementazioni dell'interfaccia di raccolta appropriata.

Oltre alle raccolte, il framework definisce diverse interfacce e classi di mappe. Le mappe memorizzano coppie chiave / valore. Sebbene le mappe non siano raccolte nell'uso corretto del termine, ma sono completamente integrate con le raccolte.

Le interfacce della collezione

Il framework delle collezioni definisce diverse interfacce. Questa sezione fornisce una panoramica di ciascuna interfaccia:

Sr.No.	Interfaccia e descrizione
1	L'interfaccia della raccolta Ciò consente di lavorare con gruppi di oggetti; è in cima alla gerarchia delle collezioni.
2	L'interfaccia della lista Questo si estende Collection e un'istanza di List memorizza una raccolta ordinata di elementi.
3	Il set Ciò estende Collection per gestire i set, che devono contenere elementi univoci.
4	Il SortedSet Questo estende Set per gestire i set ordinati.
5	La mappa Questo mappa chiavi univoche ai valori.
6	The Map.Entry Descrive un elemento (una coppia chiave / valore) in una mappa. Questa è una classe interna di Map.
7	Il SortedMap Questo estende la mappa in modo che le chiavi siano mantenute in ordine crescente.
8	L'enumerazione Questa è l'interfaccia legacy che definisce i metodi con cui è possibile enumerare (ottenerne uno alla volta) gli elementi in una raccolta di oggetti. Questa interfaccia legacy è stata sostituita da Iterator.

Le classi di raccolta

Java fornisce una serie di classi di raccolta standard che implementano le interfacce di raccolta. Alcune delle classi forniscono implementazioni complete che possono essere utilizzate così come sono e altre sono classi astratte, fornendo implementazioni scheletriche che vengono utilizzate come punti di partenza per la creazione di raccolte concrete.

Le classi di raccolta standard sono riassunte nella tabella seguente:

Sr.No.	Classe e descrizione
1	AbstractCollection Implementa la maggior parte dell'interfaccia Collection.
2	AbstractList Estende AbstractCollection e implementa la maggior parte dell'interfaccia List.
3	AbstractSequentialList Estende AbstractList per l'utilizzo da parte di una raccolta che utilizza l'accesso sequenziale anziché casuale dei suoi elementi.
4	Lista collegata Implementa un elenco collegato estendendo AbstractSequentialList.
5	Lista di array Implementa un array dinamico estendendo AbstractList.
6	AbstractSet Estende AbstractCollection e implementa la maggior parte dell'interfaccia Set.
7	HashSet Estende AbstractSet per l'uso con una tabella hash.
8	LinkedHashSet Estende HashSet per consentire iterazioni dell'ordine di inserzione.
9	TreeSet Implementa un set memorizzato in un albero. Estende AbstractSet.
10	AbstractMap Implementa la maggior parte dell'interfaccia Map.
11	HashMap Estende AbstractMap per utilizzare una tabella hash.
12	TreeMap Estende AbstractMap per utilizzare un albero.
13	WeakHashMap Estende AbstractMap per utilizzare una tabella hash con chiavi deboli.
14	LinkedHashMap Estende HashMap per consentire iterazioni dell'ordine di inserzione.
15	IdentityHashMap Estende AbstractMap e utilizza l'uguaglianza dei riferimenti durante il confronto dei documenti.

Le classi AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList e AbstractMap forniscono implementazioni scheletriche delle interfacce di raccolta principali, per ridurre al minimo lo sforzo richiesto per implementarle.

Le seguenti classi legacy definite da java.util sono state discusse nel capitolo precedente:

Sr.No.	Classe e descrizione
1	Vettore Questo implementa un array dinamico. È simile a ArrayList, ma con alcune differenze.
2	Pila Stack è una sottoclasse di Vector che implementa uno stack standard last-in, first-out.
3	Dizionario Dictionary è una classe astratta che rappresenta un repository di archiviazione chiave / valore e funziona in modo molto simile a Map.
4	Hashtable Hashtable faceva parte del java.util originale ed è un'implementazione concreta di un dizionario.
5	Proprietà Properties è una sottoclasse di Hashtable. Viene utilizzato per mantenere elenchi di valori in cui la chiave è una stringa e anche il valore è una stringa.
6	BitSet Una classe BitSet crea un tipo speciale di array che contiene valori di bit. Questa matrice può aumentare di dimensioni secondo necessità.

Gli algoritmi di raccolta

Il framework delle raccolte definisce diversi algoritmi che possono essere applicati a raccolte e mappe. Questi algoritmi sono definiti come metodi statici all'interno della classe Collections.

Molti dei metodi possono generare un file ClassCastException, che si verifica quando si tenta di confrontare tipi incompatibili o un file UnsupportedOperationException, che si verifica quando si tenta di modificare una raccolta non modificabile.

Le raccolte definiscono tre variabili statiche: EMPTY_SET, EMPTY_LIST e EMPTY_MAP. Tutti sono immutabili.

Sr.No.	Algoritmo e descrizione
1	Gli algoritmi di raccolta Ecco un elenco di tutte le implementazioni dell'algoritmo.

Come utilizzare un iteratore?

Spesso, vorrai scorrere gli elementi in una raccolta. Ad esempio, potresti voler visualizzare ogni elemento.

Il modo più semplice per farlo è utilizzare un iteratore, che è un oggetto che implementa l'interfaccia Iterator o ListIterator.

Iterator ti consente di scorrere una raccolta, ottenendo o rimuovendo elementi. ListIterator estende Iterator per consentire l'attraversamento bidirezionale di un elenco e la modifica degli elementi.

Sr.No.	Metodo e descrizione dell'iteratore
1	Utilizzo di Java Iterator Di seguito è riportato un elenco di tutti i metodi con esempi forniti dalle interfacce Iterator e ListIterator.

Come utilizzare un comparatore?

Sia TreeSet che TreeMap memorizzano gli elementi in un ordine ordinato. Tuttavia, è il comparatore che definisce esattamente il significato di ordinamento .

Questa interfaccia ci consente di ordinare una data raccolta in diversi modi. Anche questa interfaccia può essere utilizzata per ordinare qualsiasi istanza di qualsiasi classe (anche le classi che non possiamo modificare).

Sr.No.	Metodo e descrizione dell'iteratore
1	Utilizzando Java Comparator Ecco un elenco di tutti i metodi con esempi forniti da Comparator Interface.

Sommario

Il framework delle collezioni Java fornisce al programmatore l'accesso a strutture di dati preconfezionate e ad algoritmi per manipolarle.

Una raccolta è un oggetto che può contenere riferimenti ad altri oggetti. Le interfacce di raccolta dichiarano le operazioni che possono essere eseguite su ogni tipo di raccolta.

Le classi e le interfacce del framework delle collezioni si trovano nel pacchetto java.util.

Sarebbe bello se potessimo scrivere un unico metodo di ordinamento in grado di ordinare gli elementi in un array Integer, in un array String o in un array di qualsiasi tipo che supporti l'ordinamento.

Giava Generic metodi e classi generiche consentono ai programmatori di specificare, rispettivamente con una singola dichiarazione di metodo, un insieme di metodi correlati o con una singola dichiarazione di classe, un insieme di tipi correlati.

I generics forniscono anche la protezione dai tipi in fase di compilazione che consente ai programmatori di rilevare i tipi non validi in fase di compilazione.

Usando il concetto generico di Java, potremmo scrivere un metodo generico per ordinare un array di oggetti, quindi invocare il metodo generico con array Integer, Double array, String array e così via, per ordinare gli elementi dell'array.

Metodi generici

È possibile scrivere una singola dichiarazione di metodo generico che può essere chiamata con argomenti di tipi diversi. In base ai tipi di argomenti passati al metodo generico, il compilatore gestisce ogni chiamata di metodo in modo appropriato. Di seguito sono riportate le regole per definire i metodi generici:

• Tutte le dichiarazioni di metodi generici hanno una sezione del parametro di tipo delimitata da parentesi angolari (<e>) che precede il tipo restituito del metodo (<E> nell'esempio successivo).

• Ogni sezione di parametro di tipo contiene uno o più parametri di tipo separati da virgole. Un parametro di tipo, noto anche come variabile di tipo, è un identificatore che specifica un nome di tipo generico.

• I parametri di tipo possono essere utilizzati per dichiarare il tipo restituito e fungere da segnaposto per i tipi degli argomenti passati al metodo generico, noti come argomenti di tipo effettivo.

• Il corpo di un metodo generico viene dichiarato come quello di qualsiasi altro metodo. Si noti che i parametri di tipo possono rappresentare solo tipi di riferimento, non tipi primitivi (come int, double e char).

Esempio

L'esempio seguente illustra come stampare un array di tipo diverso utilizzando un unico metodo generico:

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

Questo produrrà il seguente risultato:

Produzione

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Parametri di tipo limitato

A volte potresti voler limitare i tipi di tipi che possono essere passati a un parametro di tipo. Ad esempio, un metodo che opera sui numeri potrebbe voler accettare solo istanze di Number o delle sue sottoclassi. Questo è ciò a cui servono i parametri di tipo limitato.

Per dichiarare un parametro di tipo limitato, elenca il nome del parametro di tipo, seguito dalla parola chiave extends, seguito dal suo limite superiore.

Esempio

L'esempio seguente illustra come extends sia usato in senso generale per significare "extends" (come nelle classi) o "implements" (come nelle interfacce). Questo esempio è il metodo generico per restituire il più grande dei tre oggetti comparabili:

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

Questo produrrà il seguente risultato:

Produzione

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

Classi generiche

Una dichiarazione di classe generica sembra una dichiarazione di classe non generica, tranne per il fatto che il nome della classe è seguito da una sezione di parametro di tipo.

Come con i metodi generici, la sezione dei parametri di tipo di una classe generica può avere uno o più parametri di tipo separati da virgole. Queste classi sono note come classi parametrizzate o tipi parametrizzati perché accettano uno o più parametri.

Esempio

L'esempio seguente illustra come possiamo definire una classe generica:

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

Questo produrrà il seguente risultato:

Produzione

Integer Value :10
String Value :Hello World

Java fornisce un meccanismo, chiamato serializzazione degli oggetti, in cui un oggetto può essere rappresentato come una sequenza di byte che include i dati dell'oggetto, nonché le informazioni sul tipo di oggetto e sui tipi di dati memorizzati nell'oggetto.

Dopo che un oggetto serializzato è stato scritto in un file, può essere letto dal file e deserializzato, ovvero le informazioni sul tipo ei byte che rappresentano l'oggetto ei suoi dati possono essere utilizzati per ricreare l'oggetto in memoria.

La cosa più impressionante è che l'intero processo è indipendente dalla JVM, il che significa che un oggetto può essere serializzato su una piattaforma e deserializzato su una piattaforma completamente diversa.

Classi ObjectInputStream e ObjectOutputStream sono flussi di alto livello che contengono i metodi per serializzare e deserializzare un oggetto.

La classe ObjectOutputStream contiene molti metodi di scrittura per scrivere vari tipi di dati, ma un metodo in particolare si distingue:

public final void writeObject(Object x) throws IOException

Il metodo precedente serializza un oggetto e lo invia al flusso di output. Allo stesso modo, la classe ObjectInputStream contiene il seguente metodo per deserializzare un oggetto:

public final Object readObject() throws IOException, ClassNotFoundException

Questo metodo recupera l'oggetto successivo dal flusso e lo deserializza. Il valore restituito è Object, quindi sarà necessario eseguirne il cast al tipo di dati appropriato.

Per dimostrare come funziona la serializzazione in Java, userò la classe Employee di cui abbiamo discusso all'inizio del libro. Supponiamo di avere la seguente classe Employee, che implementa l'interfaccia Serializable:

Esempio

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

Si noti che affinché una classe venga serializzata correttamente, devono essere soddisfatte due condizioni:

• La classe deve implementare l'interfaccia java.io.Serializable.

• Tutti i campi della classe devono essere serializzabili. Se un campo non è serializzabile, deve essere contrassegnatotransient.

Se sei curioso di sapere se una Java Standard Class è serializzabile o meno, controlla la documentazione per la classe. Il test è semplice: se la classe implementa java.io.Serializable, allora è serializzabile; altrimenti non lo è.

Serializzazione di un oggetto

La classe ObjectOutputStream viene utilizzata per serializzare un oggetto. Il seguente programma SerializeDemo crea un'istanza di un oggetto Employee e lo serializza in un file.

Al termine dell'esecuzione del programma, viene creato un file denominato employee.ser. Il programma non genera alcun output, ma studia il codice e cerca di determinare cosa sta facendo il programma.

Note - Quando si serializza un oggetto in un file, la convenzione standard in Java è di dare al file un .ser estensione.

Esempio

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Deserializzazione di un oggetto

Il seguente programma DeserializeDemo deserializza l'oggetto Employee creato nel programma SerializeDemo. Studia il programma e prova a determinarne l'output -

Esempio

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

Questo produrrà il seguente risultato:

Produzione

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Di seguito sono riportati i punti importanti da notare:

• Il blocco try / catch tenta di catturare un'eccezione ClassNotFoundException, dichiarata dal metodo readObject (). Affinché una JVM sia in grado di deserializzare un oggetto, deve essere in grado di trovare il bytecode per la classe. Se la JVM non riesce a trovare una classe durante la deserializzazione di un oggetto, genera un'eccezione ClassNotFoundException.

• Si noti che viene eseguito il cast del valore restituito di readObject () a un riferimento Employee.

• Il valore del campo SSN era 11122333 quando l'oggetto è stato serializzato, ma poiché il campo è transitorio, questo valore non è stato inviato al flusso di output. Il campo SSN dell'oggetto deserializzato Employee è 0.

Il termine programmazione di rete si riferisce alla scrittura di programmi che vengono eseguiti su più dispositivi (computer), in cui i dispositivi sono tutti collegati tra loro tramite una rete.

Il pacchetto java.net delle API J2SE contiene una raccolta di classi e interfacce che forniscono dettagli di comunicazione di basso livello, consentendo di scrivere programmi che si concentrano sulla risoluzione del problema in questione.

Il pacchetto java.net fornisce supporto per i due protocolli di rete comuni:

• TCP- TCP sta per Transmission Control Protocol, che consente una comunicazione affidabile tra due applicazioni. Il protocollo TCP viene generalmente utilizzato sul protocollo Internet, denominato TCP / IP.

• UDP - UDP sta per User Datagram Protocol, un protocollo senza connessione che consente la trasmissione di pacchetti di dati tra le applicazioni.

Questo capitolo fornisce una buona comprensione dei seguenti due argomenti:

• Socket Programming - Questo è il concetto più ampiamente utilizzato in Networking ed è stato spiegato in dettaglio.

• URL Processing- Questo sarebbe trattato separatamente. Fare clic qui per informazioni sull'elaborazione degli URL in linguaggio Java.

Programmazione socket

I socket forniscono il meccanismo di comunicazione tra due computer tramite TCP. Un programma client crea un socket alla fine della comunicazione e tenta di connetterlo a un server.

Quando viene stabilita la connessione, il server crea un oggetto socket alla fine della comunicazione. Il client e il server possono ora comunicare scrivendo e leggendo dal socket.

La classe java.net.Socket rappresenta un socket e la classe java.net.ServerSocket fornisce un meccanismo per il programma server per ascoltare i client e stabilire connessioni con essi.

I seguenti passaggi si verificano quando si stabilisce una connessione TCP tra due computer utilizzando i socket:

• Il server crea un'istanza di un oggetto ServerSocket, indicando su quale numero di porta deve avvenire la comunicazione.

• Il server richiama il metodo accept () della classe ServerSocket. Questo metodo attende fino a quando un client si connette al server sulla porta specificata.

• Dopo che il server è in attesa, un client crea un'istanza di un oggetto Socket, specificando il nome del server e il numero di porta a cui connettersi.

• Il costruttore della classe Socket tenta di connettere il client al server specificato e al numero di porta. Se la comunicazione è stabilita, il client ora dispone di un oggetto Socket in grado di comunicare con il server.

• Sul lato server, il metodo accept () restituisce un riferimento a un nuovo socket sul server che è connesso al socket del client.

Dopo che le connessioni sono state stabilite, la comunicazione può avvenire utilizzando flussi di I / O. Ogni socket ha sia un OutputStream che un InputStream. L'OutputStream del client è connesso all'InputStream del server e l'InputStream del client è connesso all'OutputStream del server.

TCP è un protocollo di comunicazione a due vie, quindi i dati possono essere inviati su entrambi i flussi contemporaneamente. Di seguito sono riportate le classi utili che forniscono un set completo di metodi per implementare i socket.

Metodi di classe ServerSocket

Il java.net.ServerSocket viene utilizzata dalle applicazioni server per ottenere una porta e ascoltare le richieste dei client.

La classe ServerSocket ha quattro costruttori:

Sr.No.	Metodo e descrizione
1	public ServerSocket(int port) throws IOException Tenta di creare un socket del server associato alla porta specificata. Si verifica un'eccezione se la porta è già vincolata da un'altra applicazione.
2	public ServerSocket(int port, int backlog) throws IOException Simile al costruttore precedente, il parametro backlog specifica il numero di client in ingresso da memorizzare in una coda di attesa.
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException Simile al costruttore precedente, il parametro InetAddress specifica l'indirizzo IP locale a cui collegarsi. InetAddress viene utilizzato per i server che possono avere più indirizzi IP, consentendo al server di specificare su quale dei suoi indirizzi IP accettare le richieste dei client.
4	public ServerSocket() throws IOException Crea un socket del server non associato. Quando si utilizza questo costruttore, utilizzare il metodo bind () quando si è pronti per eseguire il binding del socket del server.

Se il costruttore ServerSocket non genera un'eccezione, significa che l'applicazione è stata collegata correttamente alla porta specificata ed è pronta per le richieste del client.

Di seguito sono riportati alcuni dei metodi comuni della classe ServerSocket:

Sr.No.	Metodo e descrizione
1	public int getLocalPort() Restituisce la porta su cui è in ascolto il socket del server. Questo metodo è utile se hai passato 0 come numero di porta in un costruttore e lasci che il server trovi una porta per te.
2	public Socket accept() throws IOException Attende un client in arrivo. Questo metodo si blocca fino a quando un client si connette al server sulla porta specificata o il socket scade, assumendo che il valore di timeout sia stato impostato utilizzando il metodo setSoTimeout (). In caso contrario, questo metodo si blocca indefinitamente.
3	public void setSoTimeout(int timeout) Imposta il valore di timeout per quanto tempo il socket del server attende un client durante accept ().
4	public void bind(SocketAddress host, int backlog) Associa il socket al server e alla porta specificati nell'oggetto SocketAddress. Utilizzare questo metodo se è stata creata un'istanza di ServerSocket utilizzando il costruttore senza argomenti.

Quando ServerSocket invoca accept (), il metodo non restituisce finché un client non si connette. Dopo che un client si connette, ServerSocket crea un nuovo Socket su una porta non specificata e restituisce un riferimento a questo nuovo Socket. Esiste ora una connessione TCP tra il client e il server e la comunicazione può iniziare.

Metodi di classe socket

Il java.net.Socketclass rappresenta il socket che sia il client che il server utilizzano per comunicare tra loro. Il client ottiene un oggetto Socket istanziandone uno, mentre il server ottiene un oggetto Socket dal valore di ritorno del metodo accept ().

La classe Socket ha cinque costruttori che un client utilizza per connettersi a un server:

Sr.No.	Metodo e descrizione
1	public Socket(String host, int port) throws UnknownHostException, IOException. Questo metodo tenta di connettersi al server specificato alla porta specificata. Se questo costruttore non genera un'eccezione, la connessione ha esito positivo e il client è connesso al server.
2	public Socket(InetAddress host, int port) throws IOException Questo metodo è identico al costruttore precedente, tranne per il fatto che l'host è indicato da un oggetto InetAddress.
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Si connette all'host e alla porta specificati, creando un socket sull'host locale all'indirizzo e alla porta specificati.
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. Questo metodo è identico al costruttore precedente, ad eccezione del fatto che l'host è indicato da un oggetto InetAddress invece che da una String.
5	public Socket() Crea un socket non connesso. Usa il metodo connect () per connettere questo socket a un server.

Quando il costruttore Socket ritorna, non crea semplicemente un'istanza di un oggetto Socket, ma tenta effettivamente di connettersi al server e alla porta specificati.

Alcuni metodi di interesse per la classe Socket sono elencati qui. Si noti che sia il client che il server hanno un oggetto Socket, quindi questi metodi possono essere richiamati sia dal client che dal server.

Sr.No.	Metodo e descrizione
1	public void connect(SocketAddress host, int timeout) throws IOException Questo metodo collega il socket all'host specificato. Questo metodo è necessario solo quando si crea un'istanza del Socket utilizzando il costruttore senza argomenti.
2	public InetAddress getInetAddress() Questo metodo restituisce l'indirizzo dell'altro computer a cui è connesso questo socket.
3	public int getPort() Restituisce la porta a cui è associato il socket sulla macchina remota.
4	public int getLocalPort() Restituisce la porta a cui è associato il socket sulla macchina locale.
5	public SocketAddress getRemoteSocketAddress() Restituisce l'indirizzo del socket remoto.
6	public InputStream getInputStream() throws IOException Restituisce il flusso di input del socket. Il flusso di input è connesso al flusso di output del socket remoto.
7	public OutputStream getOutputStream() throws IOException Restituisce il flusso di output del socket. Il flusso di output è connesso al flusso di input del socket remoto.
8	public void close() throws IOException Chiude il socket, il che rende questo oggetto Socket non più in grado di connettersi nuovamente a nessun server.

Metodi di classe InetAddress

Questa classe rappresenta un indirizzo IP (Internet Protocol). Di seguito sono riportati i metodi utili di cui avresti bisogno durante la programmazione dei socket:

Sr.No.	Metodo e descrizione
1	static InetAddress getByAddress(byte[] addr) Restituisce un oggetto InetAddress dato l'indirizzo IP non elaborato.
2	static InetAddress getByAddress(String host, byte[] addr) Crea un InetAddress in base al nome host e all'indirizzo IP forniti.
3	static InetAddress getByName(String host) Determina l'indirizzo IP di un host, dato il nome dell'host.
4	String getHostAddress() Restituisce la stringa dell'indirizzo IP nella presentazione testuale.
5	String getHostName() Ottiene il nome host per questo indirizzo IP.
6	static InetAddress InetAddress getLocalHost() Restituisce l'host locale.
7	String toString() Converte questo indirizzo IP in una stringa.

Esempio di client socket

Il seguente GreetingClient è un programma client che si connette a un server utilizzando un socket e invia un saluto, quindi attende una risposta.

Esempio

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Esempio di server socket

Il seguente programma GreetingServer è un esempio di un'applicazione server che utilizza la classe Socket per ascoltare i client su un numero di porta specificato da un argomento della riga di comando:

Esempio

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Compilare il client e il server, quindi avviare il server come segue:

$ java GreetingServer 6066
Waiting for client on port 6066...

Controllare il programma client come segue:

Produzione

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Inviare un'e-mail utilizzando la tua applicazione Java è abbastanza semplice, ma per iniziare dovresti averlo JavaMail API e Java Activation Framework (JAF) installato sulla tua macchina.

• È possibile scaricare l'ultima versione di JavaMail (Versione 1.2) dal sito Web standard di Java.

• È possibile scaricare l'ultima versione di JAF (versione 1.1.1) dal sito Web standard di Java.

Scarica e decomprimi questi file, nelle directory di primo livello appena create troverai una serie di file jar per entrambe le applicazioni. Devi aggiungeremail.jar e activation.jar file nel tuo CLASSPATH.

Invia una semplice e-mail

Ecco un esempio per inviare una semplice e-mail dalla tua macchina. Si presume che il tuolocalhost è connesso a Internet e in grado di inviare un messaggio di posta elettronica.

Esempio

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {    
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Now set the actual message
         message.setText("This is actual message");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compila ed esegui questo programma per inviare una semplice e-mail -

Produzione

$ java SendEmail
Sent message successfully....

Se si desidera inviare un'e-mail a più destinatari, verranno utilizzati i seguenti metodi per specificare più ID e-mail:

void addRecipients(Message.RecipientType type, Address[] addresses)
   throws MessagingException

Ecco la descrizione dei parametri:

• type- Questo sarebbe impostato su TO, CC o BCC. Qui CC rappresenta Carbon Copy e BCC rappresenta Black Carbon Copy. Esempio: Message.RecipientType.TO

• addresses- Questo è un array di ID e-mail. Dovresti usare il metodo InternetAddress () mentre specifichi gli ID email.

Invia un'e-mail HTML

Ecco un esempio per inviare un'e-mail HTML dalla tua macchina. Qui si presume che il tuo filelocalhost è connesso a Internet e in grado di inviare un messaggio di posta elettronica.

Questo esempio è molto simile al precedente, tranne che qui stiamo usando il metodo setContent () per impostare il contenuto il cui secondo argomento è "text / html" per specificare che il contenuto HTML è incluso nel messaggio.

Usando questo esempio, puoi inviare un contenuto HTML grande quanto ti piace.

Esempio

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendHTMLEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compila ed esegui questo programma per inviare un'e-mail HTML -

Produzione

$ java SendHTMLEmail
Sent message successfully....

Invia allegato in posta elettronica

Ecco un esempio per inviare un'e-mail con allegato dalla tua macchina. Qui si presume che il tuo filelocalhost è connesso a Internet e sufficientemente in grado di inviare un'e-mail.

Esempio

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

   public static void main(String [] args) {     
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();

         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();

         // Set text message part
         multipart.addBodyPart(messageBodyPart);

         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);

         // Send the complete message parts
         message.setContent(multipart );

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compila ed esegui questo programma per inviare un'e-mail HTML -

Produzione

$ java SendFileEmail
Sent message successfully....

Parte autenticazione utente

Se è necessario fornire ID utente e password al server di posta elettronica a scopo di autenticazione, è possibile impostare queste proprietà come segue:

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

Il resto del meccanismo di invio della posta elettronica rimarrebbe come spiegato sopra.

Java è un linguaggio di programmazione multi-thread che significa che possiamo sviluppare programmi multi-thread utilizzando Java. Un programma multi-thread contiene due o più parti che possono essere eseguite contemporaneamente e ciascuna parte può gestire un'attività diversa allo stesso tempo, facendo un uso ottimale delle risorse disponibili specialmente quando il tuo computer ha più CPU.

Per definizione, il multitasking è quando più processi condividono risorse di elaborazione comuni come una CPU. Il multi-threading estende l'idea del multitasking in applicazioni in cui è possibile suddividere operazioni specifiche all'interno di una singola applicazione in singoli thread. Ciascuno dei thread può essere eseguito in parallelo. Il sistema operativo divide il tempo di elaborazione non solo tra le diverse applicazioni, ma anche tra ogni thread all'interno di un'applicazione.

Il multi-threading consente di scrivere in un modo in cui più attività possono procedere contemporaneamente nello stesso programma.

Ciclo di vita di un filo

Un filo attraversa varie fasi del suo ciclo di vita. Ad esempio, un thread nasce, avviato, viene eseguito e quindi muore. Il diagramma seguente mostra il ciclo di vita completo di un thread.

Di seguito sono riportate le fasi del ciclo di vita:

• New- Un nuovo thread inizia il suo ciclo di vita nel nuovo stato. Rimane in questo stato finché il programma non avvia il thread. Viene anche chiamatoborn thread.

• Runnable- Dopo l'avvio di un thread appena nato, il thread diventa eseguibile. Si considera che un thread in questo stato stia eseguendo la sua attività.

• Waiting- A volte, un thread passa allo stato di attesa mentre il thread attende che un altro thread esegua un'attività. Un thread torna allo stato eseguibile solo quando un altro thread segnala al thread in attesa di continuare l'esecuzione.

• Timed Waiting- Un thread eseguibile può entrare nello stato di attesa a tempo per un intervallo di tempo specificato. Un thread in questo stato torna allo stato eseguibile quando scade l'intervallo di tempo o quando si verifica l'evento che è in attesa.

• Terminated (Dead) - Un thread eseguibile entra nello stato terminato quando completa la sua attività o termina in altro modo.

Priorità thread

Ogni thread Java ha una priorità che aiuta il sistema operativo a determinare l'ordine in cui sono pianificati i thread.

Le priorità dei thread Java sono nell'intervallo tra MIN_PRIORITY (una costante di 1) e MAX_PRIORITY (una costante di 10). Per impostazione predefinita, a ogni thread viene assegnata la priorità NORM_PRIORITY (una costante di 5).

I thread con priorità più alta sono più importanti per un programma e dovrebbero essere allocati tempo processore prima dei thread con priorità più bassa. Tuttavia, le priorità dei thread non possono garantire l'ordine in cui vengono eseguiti i thread e sono molto dipendenti dalla piattaforma.

Crea un thread implementando un'interfaccia eseguibile

Se la tua classe è concepita per essere eseguita come thread, puoi ottenere ciò implementando un file Runnableinterfaccia. Dovrai seguire tre passaggi fondamentali:

Passo 1

Come primo passo, è necessario implementare un metodo run () fornito da un file Runnableinterfaccia. Questo metodo fornisce un punto di ingresso per il thread e inserirai la tua logica aziendale completa all'interno di questo metodo. Di seguito è riportata una semplice sintassi del metodo run ():

public void run( )

Passo 2

Come secondo passaggio, istanzerai un file Thread oggetto utilizzando il seguente costruttore:

Thread(Runnable threadObj, String threadName);

Dove, threadObj è un'istanza di una classe che implementa ilRunnable interfaccia e threadName è il nome dato al nuovo thread.

Passaggio 3

Una volta creato un oggetto Thread, puoi avviarlo chiamando start()metodo, che esegue una chiamata al metodo run (). Di seguito è riportata una semplice sintassi del metodo start ():

void start();

Esempio

Ecco un esempio che crea un nuovo thread e inizia a eseguirlo:

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

Questo produrrà il seguente risultato:

Produzione

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Creare un thread estendendo una classe di thread

Il secondo modo per creare un thread è creare una nuova classe che si estende Threadclasse utilizzando i seguenti due semplici passaggi. Questo approccio fornisce una maggiore flessibilità nella gestione di più thread creati utilizzando i metodi disponibili nella classe Thread.

Passo 1

Dovrai eseguire l'override run( )metodo disponibile nella classe Thread. Questo metodo fornisce un punto di ingresso per il thread e inserirai la tua logica aziendale completa all'interno di questo metodo. Di seguito è riportata una semplice sintassi del metodo run ():

public void run( )

Passo 2

Una volta creato l'oggetto Thread, puoi avviarlo chiamando start()metodo, che esegue una chiamata al metodo run (). Di seguito è riportata una semplice sintassi del metodo start ():

void start( );

Esempio

Ecco il programma precedente riscritto per estendere il thread -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

Questo produrrà il seguente risultato:

Produzione

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Metodi di filettatura

Di seguito è riportato l'elenco dei metodi importanti disponibili nella classe Thread.

Sr.No.	Metodo e descrizione
1	public void start() Avvia il thread in un percorso di esecuzione separato, quindi richiama il metodo run () su questo oggetto Thread.
2	public void run() Se questo oggetto Thread è stato istanziato utilizzando un target Runnable separato, il metodo run () viene invocato su quell'oggetto Runnable.
3	public final void setName(String name) Modifica il nome dell'oggetto Thread. C'è anche un metodo getName () per recuperare il nome.
4	public final void setPriority(int priority) Imposta la priorità di questo oggetto Thread. I valori possibili sono compresi tra 1 e 10.
5	public final void setDaemon(boolean on) Un parametro true denota questo thread come un thread daemon.
6	public final void join(long millisec) Il thread corrente richiama questo metodo su un secondo thread, causando il blocco del thread corrente fino al termine del secondo thread o al numero di millisecondi specificato.
7	public void interrupt() Interrompe questo thread, provocando la continuazione dell'esecuzione se è stato bloccato per qualsiasi motivo.
8	public final boolean isAlive() Restituisce vero se il thread è attivo, ovvero in qualsiasi momento dopo che il thread è stato avviato ma prima che venga eseguito fino al completamento.

I metodi precedenti vengono richiamati su un particolare oggetto Thread. I metodi seguenti nella classe Thread sono statici. Invocare uno dei metodi statici esegue l'operazione sul thread attualmente in esecuzione.

Sr.No.	Metodo e descrizione
1	public static void yield() Fa sì che il thread attualmente in esecuzione ceda a qualsiasi altro thread con la stessa priorità in attesa di essere pianificato.
2	public static void sleep(long millisec) Causa il blocco del thread attualmente in esecuzione per almeno il numero di millisecondi specificato.
3	public static boolean holdsLock(Object x) Restituisce vero se il thread corrente mantiene il blocco sull'oggetto specificato.
4	public static Thread currentThread() Restituisce un riferimento al thread attualmente in esecuzione, che è il thread che richiama questo metodo.
5	public static void dumpStack() Stampa la traccia dello stack per il thread attualmente in esecuzione, utile durante il debug di un'applicazione multithread.

Esempio

Il seguente programma ThreadClassDemo mostra alcuni di questi metodi della classe Thread. Considera una lezioneDisplayMessage che implementa Runnable -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

Di seguito è riportata un'altra classe che estende la classe Thread:

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

Di seguito è riportato il programma principale, che utilizza le classi sopra definite:

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

Questo produrrà il seguente risultato. Puoi provare questo esempio ancora e ancora e otterrai ogni volta un risultato diverso.

Produzione

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Principali concetti di multithreading Java

Durante la programmazione multithreading in Java, è necessario avere i seguenti concetti molto utili:

• Cos'è la sincronizzazione dei thread?

• Gestione della comunicazione interthread

• Gestione del deadlock del thread

• Principali operazioni sui thread

Un appletè un programma Java che viene eseguito in un browser Web. Un'applet può essere un'applicazione Java completamente funzionante perché dispone dell'intera API Java.

Esistono alcune importanti differenze tra un'applet e un'applicazione Java autonoma, tra cui le seguenti:

• Un applet è una classe Java che estende la classe java.applet.Applet.

• Un metodo main () non viene invocato su un'applet e una classe applet non definirà main ().

• Gli applet sono progettati per essere incorporati in una pagina HTML.

• Quando un utente visualizza una pagina HTML che contiene un'applet, il codice per l'applet viene scaricato sulla macchina dell'utente.

• È necessaria una JVM per visualizzare un'applet. La JVM può essere un plug-in del browser Web o un ambiente di runtime separato.

• La JVM sulla macchina dell'utente crea un'istanza della classe applet e richiama vari metodi durante la vita dell'applet.

• Le applet hanno regole di sicurezza rigorose che vengono applicate dal browser Web. La sicurezza di un'applet viene spesso definita sicurezza sandbox, confrontando l'applet con un bambino che gioca in una sandbox con varie regole che devono essere seguite.

• Altre classi di cui l'applet necessita possono essere scaricate in un singolo file JAR (Java Archive).

Ciclo di vita di un'applet

Quattro metodi nella classe Applet ti danno il framework su cui costruire qualsiasi applet seria -

• init- Questo metodo è inteso per qualsiasi inizializzazione sia necessaria per l'applet. Viene chiamato dopo che i tag param all'interno del tag dell'applet sono stati elaborati.

• start- Questo metodo viene chiamato automaticamente dopo che il browser chiama il metodo init. Viene chiamato anche ogni volta che l'utente torna alla pagina contenente l'applet dopo essere passato ad altre pagine.

• stop- Questo metodo viene chiamato automaticamente quando l'utente esce dalla pagina su cui si trova l'applet. Può quindi essere richiamato ripetutamente nella stessa applet.

• destroy- Questo metodo viene chiamato solo quando il browser si chiude normalmente. Poiché gli applet sono pensati per vivere su una pagina HTML, normalmente non dovresti lasciare le risorse dietro dopo che un utente lascia la pagina che contiene l'applet.

• paint- Richiamato immediatamente dopo il metodo start () e ogni volta che l'applet deve ridipingere se stessa nel browser. Il metodo paint () è effettivamente ereditato da java.awt.

Un'applet "Hello, World"

Di seguito è riportato un semplice applet denominato HelloWorldApplet.java -

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet {
   public void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

Queste istruzioni di importazione portano le classi nell'ambito della nostra classe applet -

• java.applet.Applet
• java.awt.Graphics

Senza queste istruzioni di importazione, il compilatore Java non riconoscerebbe le classi Applet e Graphics, a cui fa riferimento la classe applet.

La classe Applet

Ogni applet è un'estensione della classe java.applet.Applet . La classe Applet di base fornisce metodi che una classe Applet derivata può chiamare per ottenere informazioni e servizi dal contesto del browser.

Questi includono metodi che eseguono le seguenti operazioni:

• Ottieni i parametri dell'applet
• Ottieni il percorso di rete del file HTML che contiene l'applet
• Ottieni il percorso di rete della directory della classe dell'applet
• Stampa un messaggio di stato nel browser
• Recupera un'immagine
• Recupera un clip audio
• Riproduci un clip audio
• Ridimensiona l'applet

Inoltre, la classe Applet fornisce un'interfaccia mediante la quale il visualizzatore o il browser ottiene informazioni sull'applet e controlla l'esecuzione dell'applet. Lo spettatore può -

• Richiedi informazioni su autore, versione e copyright dell'applet
• Richiedi una descrizione dei parametri che l'applet riconosce
• Inizializza l'applet
• Distruggi l'applet
• Avvia l'esecuzione dell'applet
• Ferma l'esecuzione dell'applet

La classe Applet fornisce implementazioni predefinite di ciascuno di questi metodi. Tali implementazioni possono essere sovrascritte secondo necessità.

L'applet "Hello, World" è completa così com'è. L'unico metodo ignorato è il metodo paint.

Invocare un'applet

È possibile richiamare un'applet incorporando le direttive in un file HTML e visualizzando il file tramite un visualizzatore di applet o un browser abilitato per Java.

Il tag <applet> è la base per incorporare un'applet in un file HTML. Di seguito è riportato un esempio che richiama l'applet "Hello, World":

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note- È possibile fare riferimento al tag dell'applet HTML per saperne di più sulla chiamata di applet da HTML.

L'attributo code del tag <applet> è obbligatorio. Specifica la classe Applet da eseguire. La larghezza e l'altezza sono necessarie anche per specificare la dimensione iniziale del pannello in cui viene eseguita un'applet. La direttiva applet deve essere chiusa con un tag </applet>.

Se un'applet accetta parametri, i valori possono essere passati per i parametri aggiungendo tag <param> tra <applet> e </applet>. Il browser ignora il testo e altri tag tra i tag dell'applet.

I browser non abilitati a Java non elaborano <applet> e </applet>. Pertanto, tutto ciò che appare tra i tag, non correlato all'applet, è visibile nei browser non abilitati a Java.

Il visualizzatore o il browser cerca il codice Java compilato nella posizione del documento. Per specificare diversamente, usa l'attributo codebase del tag <applet> come mostrato -

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

Se un'applet risiede in un pacchetto diverso da quello predefinito, il pacchetto di contenimento deve essere specificato nell'attributo code utilizzando il carattere punto (.) Per separare i componenti pacchetto / classe. Ad esempio:

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

Recupero dei parametri dell'applet

L'esempio seguente mostra come fare in modo che un'applet risponda ai parametri di configurazione specificati nel documento. Questa applet mostra un motivo a scacchiera di nero e un secondo colore.

Il secondo colore e la dimensione di ogni quadrato possono essere specificati come parametri per l'applet all'interno del documento.

CheckerApplet ottiene i suoi parametri nel metodo init (). Può anche ottenere i suoi parametri nel metodo paint (). Tuttavia, ottenere i valori e salvare le impostazioni una volta all'inizio dell'applet, invece che a ogni aggiornamento, è comodo ed efficiente.

Il visualizzatore di applet o il browser chiama il metodo init () di ogni applet che esegue. Il visualizzatore chiama init () una volta, subito dopo aver caricato l'applet. (Applet.init () è implementato per non fare nulla.) Sostituire l'implementazione predefinita per inserire il codice di inizializzazione personalizzato.

Il metodo Applet.getParameter () recupera un parametro dato il nome del parametro (il valore di un parametro è sempre una stringa). Se il valore è numerico o altri dati non di carattere, la stringa deve essere analizzata.

Quello che segue è uno scheletro di CheckerApplet.java -

import java.applet.*;
import java.awt.*;

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

Ecco i metodi init () e parseSquareSize () di CheckerApplet -

public void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

L'applet chiama parseSquareSize () per analizzare il parametro squareSize. parseSquareSize () chiama il metodo della libreria Integer.parseInt (), che analizza una stringa e restituisce un numero intero. Integer.parseInt () genera un'eccezione ogni volta che il suo argomento non è valido.

Pertanto, parseSquareSize () rileva le eccezioni, invece di consentire all'applet di fallire in caso di input errato.

L'applet chiama parseColor () per analizzare il parametro color in un valore Color. parseColor () esegue una serie di confronti di stringhe per abbinare il valore del parametro al nome di un colore predefinito. È necessario implementare questi metodi per far funzionare l'applet.

Specifica dei parametri dell'applet

Quello che segue è un esempio di un file HTML con un CheckerApplet incorporato in esso. Il file HTML specifica entrambi i parametri all'applet tramite il tag <param>.

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note - I nomi dei parametri non fanno distinzione tra maiuscole e minuscole.

Conversione dell'applicazione in applet

È facile convertire un'applicazione grafica Java (ovvero un'applicazione che utilizza AWT e che puoi avviare con il programma di avvio Java) in un'applet che puoi incorporare in una pagina web.

Di seguito sono riportati i passaggi specifici per convertire un'applicazione in un'applet.

• Crea una pagina HTML con il tag appropriato per caricare il codice dell'applet.

• Fornisci una sottoclasse della classe JApplet. Rendi pubblico questo corso. In caso contrario, l'applet non può essere caricata.

• Elimina il metodo principale nell'applicazione. Non costruire una finestra con cornice per l'applicazione. La tua applicazione verrà visualizzata all'interno del browser.

• Spostare qualsiasi codice di inizializzazione dal costruttore della finestra del frame al metodo init dell'applet. Non è necessario costruire esplicitamente l'oggetto applet. Il browser lo istanzia per te e chiama il metodo init.

• Rimuovere la chiamata a setSize; per le applet, il dimensionamento viene eseguito con i parametri di larghezza e altezza nel file HTML.

• Rimuovere la chiamata a setDefaultCloseOperation. Non è possibile chiudere un'applet; termina alla chiusura del browser.

• Se l'applicazione chiama setTitle, elimina la chiamata al metodo. Le applet non possono avere barre del titolo. (Puoi, ovviamente, dare un titolo alla pagina web stessa, usando il tag del titolo HTML.)

• Non chiamare setVisible (true). L'applet viene visualizzata automaticamente.

Gestione degli eventi

Le applet ereditano un gruppo di metodi di gestione degli eventi dalla classe Container. La classe Container definisce diversi metodi, come processKeyEvent e processMouseEvent, per la gestione di particolari tipi di eventi, e quindi un metodo catch-all chiamato processEvent.

Per reagire a un evento, un'applet deve sovrascrivere il metodo specifico dell'evento appropriato.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

public class ExampleEventHandling extends Applet implements MouseListener {
   StringBuffer strBuffer;

   public void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   public void mouseEntered(MouseEvent event) {
   }
   public void mouseExited(MouseEvent event) {
   }
   public void mousePressed(MouseEvent event) {
   }
   public void mouseReleased(MouseEvent event) {
   }
   public void mouseClicked(MouseEvent event) {
      addItem("mouse clicked! ");
   }
}

Ora, chiamiamo questa applet come segue:

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

Inizialmente, l'applet visualizzerà "inizializzazione dell'applet. Avvio dell'applet". Quindi, una volta che si fa clic all'interno del rettangolo, verrà visualizzato anche "clic del mouse".

Visualizzazione delle immagini

Un'applet può visualizzare immagini nel formato GIF, JPEG, BMP e altri. Per visualizzare un'immagine all'interno dell'applet, utilizzare il metodo drawImage () che si trova nella classe java.awt.Graphics.

Di seguito è riportato un esempio che illustra tutti i passaggi per mostrare le immagini:

import java.applet.*;
import java.awt.*;
import java.net.*;

public class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

Ora, chiamiamo questa applet come segue:

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

Riproduzione di audio

Un'applet può riprodurre un file audio rappresentato dall'interfaccia AudioClip nel pacchetto java.applet. L'interfaccia AudioClip ha tre metodi, tra cui:

• public void play() - Riproduce il clip audio una volta, dall'inizio.

• public void loop() - Fa sì che il clip audio venga riprodotto continuamente.

• public void stop() - Interrompe la riproduzione del clip audio.

Per ottenere un oggetto AudioClip, è necessario richiamare il metodo getAudioClip () della classe Applet. Il metodo getAudioClip () restituisce immediatamente, indipendentemente dal fatto che l'URL si risolva o meno in un file audio effettivo. Il file audio non viene scaricato fino a quando non si tenta di riprodurre il clip audio.

Di seguito è riportato un esempio che illustra tutti i passaggi per riprodurre un audio:

import java.applet.*;
import java.awt.*;
import java.net.*;

public class AudioDemo extends Applet {
   private AudioClip clip;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         clip = context.getAudioClip(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

Ora, chiamiamo questa applet come segue:

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

Puoi usare test.wav sul tuo PC per testare l'esempio sopra.

Il linguaggio Java supporta tre tipi di commenti:

Sr.No.	Commento e descrizione
1	/* text */ Il compilatore ignora tutto da / * a * /.
2	//text Il compilatore ignora tutto da // alla fine della riga.
3	/** documentation */ Questo è un commento alla documentazione e in generale è chiamato doc comment. IlJDK javadoclo strumento utilizza i commenti ai documenti quando prepara la documentazione generata automaticamente.

Questo capitolo è tutto sulla spiegazione di Javadoc. Vedremo come utilizzare Javadoc per generare documentazione utile per il codice Java.

Cos'è Javadoc?

Javadoc è uno strumento fornito con JDK e viene utilizzato per generare la documentazione del codice Java in formato HTML dal codice sorgente Java, che richiede la documentazione in un formato predefinito.

Di seguito è riportato un semplice esempio in cui le righe all'interno di /*….*/ sono commenti Java su più righe. Allo stesso modo, la riga che precede // è un commento a riga singola Java.

Esempio

/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

È possibile includere tag HTML obbligatori all'interno della parte della descrizione. Ad esempio, il seguente esempio utilizza <h1> .... </h1> per l'intestazione e <p> è stato utilizzato per creare un'interruzione di paragrafo -

Esempio

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* 
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

I tag javadoc

Lo strumento javadoc riconosce i seguenti tag:

Etichetta	Descrizione	Sintassi
@autore	Aggiunge l'autore di una classe.	@autore nome-testo
{@codice}	Visualizza il testo nel font del codice senza interpretarlo come markup HTML o tag javadoc nidificati.	{@code text}
{@docRoot}	Rappresenta il percorso relativo alla directory principale del documento generato da qualsiasi pagina generata.	{@docRoot}
@deprecato	Aggiunge un commento che indica che questa API non dovrebbe più essere utilizzata.	@deprecated deprecatedtext
@eccezione	Aggiunge un file Throws sottotitolo alla documentazione generata, con il nome della classe e il testo della descrizione.	@exception descrizione nome-classe
{@inheritDoc}	Eredita un commento da nearest classe ereditabile o interfaccia implementabile.	Eredita un commento dalla surperclasse immediata.
{@link}	Inserisce un collegamento in linea con l'etichetta di testo visibile che punta alla documentazione per il pacchetto, la classe o il nome membro di una classe a cui si fa riferimento.	{@link package.class # member label}
{@linkplain}	Identico a {@link}, tranne per il fatto che l'etichetta del link viene visualizzata in testo normale rispetto al carattere del codice.	{@linkplain package.class # member label}
@param	Aggiunge un parametro con il nome parametro specificato seguito dalla descrizione specificata nella sezione "Parametri".	@param descrizione nome parametro
@ritorno	Aggiunge una sezione "Resi" con il testo della descrizione.	@return descrizione
@vedere	Aggiunge un'intestazione "Vedere anche" con un collegamento o una voce di testo che punta a un riferimento.	@ vedi riferimento
@seriale	Utilizzato nel commento del documento per un campo serializzabile predefinito.	@serial campo-descrizione | includere | escludere
@serialData	Documenta i dati scritti dai metodi writeObject () o writeExternal ().	@serialData data-description
@serialField	Documenta un componente ObjectStreamField.	@serialField nome-campo tipo-campo descrizione-campo
@da	Aggiunge un'intestazione "Da" con il testo specificato dal momento alla documentazione generata.	@ dal rilascio
@throws	I tag @throws e @exception sono sinonimi.	@throws descrizione del nome della classe
{@valore}	Quando {@value} viene utilizzato nel commento del documento di un campo statico, visualizza il valore di quella costante.	{@value package.class # field}
@versione	Aggiunge un sottotitolo "Versione" con il testo della versione specificato ai documenti generati quando viene utilizzata l'opzione -version.	@version version-text

Esempio

Il seguente programma utilizza alcuni dei tag importanti disponibili per i commenti sulla documentazione. Puoi utilizzare altri tag in base alle tue esigenze.

La documentazione sulla classe AddNum verrà prodotta nel file HTML AddNum.html ma allo stesso tempo verrà creato anche un file master con un nome index.html.

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31
*/
public class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   public int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   public static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

Ora, elabora il file AddNum.java sopra utilizzando l'utilità javadoc come segue:

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

Puoi controllare tutta la documentazione generata qui - AddNum . Se stai usando JDK 1.7, javadoc non genera un ottimostylesheet.css, quindi suggeriamo di scaricare e utilizzare il foglio di stile standard da https://docs.oracle.com/javase/7/docs/api/stylesheet.css