Cum creem fișiere executabile în Java?

Utilitarul jar (Java Archive) care face parte din pachetul JDK oferă oportunitatea de a crea arhive jar executabile. O astfel de arhivă invocă metoda main a unei clase la efectuarea unui click dublu pe aceasta. 

Pentru a crea un fișier java executabil, este necesar crearea fișierului manifest ce are extensia .mf. 

Ps! Mai întâi și întâi trebuie, desigur, să aveți finisat codul aplicației sau proiectului. Eu am creat anterior un mini Notepad.

Pentru a crea fișierul manifest utilizați aplicația Notepad sau Wordpad și respectați sintaxa conținutului acestuia:

Main-Class: First 

First este numele clasei principale. De exemplu:

Main-Class: Notepad 

În fișierul .mf după numele clasei se va însera obligatoriu un rând liber. Salvați fișierul cu extensia .mf.

Folosind aplicația CMD, compilați aplicația Java:

Creați arhiva respecând sintaxa:

jar -cvmf myfile.mf myjar.jar First.class 

myfile.mf - numele fișierului manifest 

myjar.jar – numele viitoarei arhive jar 

First.class - numele fișierului binar creat de către JVM în urma compilării reușite a aplicației Java. 

Deci, conform exemplului meu:

În rezultat, în dosarul cu fișierele de lucru a fost creată arhiva executabila Java, Notepad.jar:

După executarea a dublu click pe acestă arhivă se va invoca metoda main() a aplicației:

Sper că această postare vă este utilă.

Este binevenit orice comentariu!

Să aveți parte de o zi extraordinară !!!!!

Sursă de documentare: 

https://www.javatpoint.com/how-to-make-an-executable-jar-file-in-java

Clasele ce descriu excepții în Java

Procesul de programare va fi mereu însoțit și de diverse probleme legate de viitorul soft. Programatorului îi revine misiunea de a prezice care sunt aceste probleme ce pot apărea în procesul execuției software-ului și de a reduce la minim apariția acestora. 

O excepție este un eveniment anormal ce apare în timpul execuției unui program şi duce la oprirea acestuia. 

Procesul de izolare a situațiilor excepționale și controlul comportării aplicației în momentul apariției acestora este numit tratarea excepțiilor. 

O excepție poate fi generată din diverse motive: împărțirea la 0, deschiderea unui fişier care nu există, accesarea indexului unui tablou care depășește limitele acestuia, ș.a. 

Java pune la dispoziția programatorilor clasa Throwable din care sunt extinse toate celelalte excepții, şi care face parte din următoarea ierarhie:

Clasa Object este părintele tuturor claselor Java. 

Clasa Throwable împarte excepțiile în 2 categorii : 

- Verificate (checked): sunt excepții verificate la faza de compilare. Nu țin de algoritm, ci de anumite condiții care ar putea afecta execuția programului (ex. fișier absent, date de intrare nevalide, probleme ce țin de baze de date, ș.a). Dacă un oarecare cod dintr-o metodă ar putea genera o astfel de excepție atunci este obligatoriu de a oferi un mecanism de tratate a acesteia fie prin try...catch fie cu ajutorul cuvântul rezervat throws, în caz contrar aplicația nu va putea fi lansată la execuție. Programatorul este forțat să trateze așa tip de excepții. 

- Neverificate (unchecked): sunt excepții care nu sunt verificate la faza de compilare ci la faza de execuție, și sunt o consecință a neatenției programatorului la elaborarea algoritmului (ex. împărțirea la 0, accesarea unui membru care nu există, ș.a). Acestea deasemenea pot fi tratate, însă la discreția programatorului.

În Java excepțiile derivate din clasele Error și RuntimeException sunt excepții neverificate (unchecked), orice altă clasă de excepție derivată din Throwable este verificată (checked). 

Instanțele clasei Error reprezintă erori interne, nerecuperabile, ale mediului de lucru Java. Aceste erori sunt rare şi de obiecei fatale, nu le putem intercepta, însă există pentru ca Java să le poată folosi dacă are nevoie de ele.

Iata câteva excepții predefinite ale limbajului Java:

ArithmeticException	Eroare de tip aritmetic, de exemplu împărțire la zero.
ArrayIndexOutOfBoundsException	Indexul din sir este în afara limitelor
ArrayStoreException	Se încearcă atribuirea unui element din șir cu o valoare incorectă.
ClassCastException	Cast incorect.
IllegalArgumentException	Parametrul transmis metodei este greșit.
IndexOutOfBoundsException	Indexul este în afara limitelor
NullPointerException	Folosirea obiectului neinstanțiat (egal cu null).
NumberFormatException	Conversia dintr-un string într-un numar a eșuat.
StringIndexOutOfBounds	Indexul unui string este in afara limitelor
IllegalAccessException	Acces la clasa nepermis.
NoSuchFieldException	S-a încercat accesarea unui membru care nu exista.
NoSuchMethodException	S-a încercat accesarea unei metode care nu exista.

Java, la fel ca alte limbaje de programare, oferă tehnici speciale ce permit interceptarea și tratarea excepțiilor într-un mod standard și destul de comod.

În Java tratarea excepțiilor este obligatorie, orice secvență de cod ce poate provoca excepții trebuie să fie însoțită şi de o modalitate de tratare a acesteia:

1) declararea excepției în semnătură metodei:
De exemplu:

public static void main(String [] args) throws FileNotFoundException { 

   // corpul metodei ce conține codul ce poate genera excepții 

} 

2) folosind blocurile try ... catch...finally:

Blocul try blochează toate instrucțiunile ce pot genera excepții. Are sintaxa :
try{
 // instrucțiuni ce pot genera excepții
}

Rețineți!

1) Un bloc try poate fi urmat fie de un bloc catch fie de un bloc finally, însă nu poate exista  

    de unul singur.

2) Dacă instrucțiunile grupate de blocul try vor genera o excepție aceasta va fi tratată de 

    blocul catch corespunzător tipului de eroare aruncată (generată).

3) Dacă instrucțiunile se vor executa cu succes nu se va mai ține cont de tratarea 

    excepțiilor şi aplicaţia se va executa în mod normal. 

Blocul catch este blocul în care sunt tratate excepțiile. Are sintaxa :

catch (ClasaDeExceptii numeVariabila{ 
       // instrucţiuni de tratare 
} 

ClasaDeExceptii reprezintă clasa excepției tratate. numeVariabila este o variabilă cu ajutorul căreia putem accesa metodele clasei excepției tratate. Deseori cu această variabilă nu se lucrează dar şi în acest caz ea trebuie declarată obligatoriu altfel obținem eroare sintactică precum că nu s-a respectat sintaxa instrucţiunii catch.

Rețineți!

1) Blocul catch NU poate exista singur, ci doar însoțit de un bloc try.

try {...
}catch(...){

}

2) Între blocul try şi primul bloc catch nu pot exista alte instrucțiuni.
3) Un bloc try poate fi însoțit de orice număr de blocuri catch.

Dacă în exemplul de mai sus vom încerca să afișăm s[1] vom obține la ecran valoarea 2. 

Blocul finally nu apare niciodată singur ci în asociere cu blocul try. Cuprinde codul care trebuie să se execute indiferent dacă apar excepții în blocul try sau nu. 

Prin clauza finally instrucțiunea try... catch devine completă. 

Acest bloc are sintaxa :
finally {
// instrucțiuni executate indiferent
}

Instrucțiunea try...catch...finally are următoarea formă completă :

Exemplu: 

class exe6 {
 public static void main(String [] args){
  int x= (int)(Math.random()*5);
  int y= (int)(Math.random()*8);
  int [] z={1,2,3,4,5};
  try {
   System.out.println("Sau generat numerel : "+x+" "+y);
   System.out.println("x/y este "+x/y);
   System.out.println("y="+y+"z[y]="+z[y]);
  }catch (ArithmeticException e1 ){
    System.out.println("problema aritmetica : Impartire la 0");
  }catch (IndexOutOfBoundsException e2){
    System.out.println("depasire de index"+e2);
  }finally { System.out.println("Elaborat de mine !");
}}

}

Programatorul, la rândul său deasemenea poate defini și genera excepții proprii cu ajutorul instrucțiunii throw.

De obicei de acest lucru este nevoie atunci când apare o situație în care oricare excepție predefinită Java nu este relevantă. Pentru aceasta este suficient de a definiti o clasa derivată din Exception. 

Clasele derivate de utilizator nu trebuie sa implementeze nimic, simpla lor apartenență la ierarhia de tipuri permite utilizarea lor ca excepții. 

Clasele create de utilizator dispun, prin moștenire, de proprietățile și metodele definite de clasa Exception. 

Pentru a trata o astfel de excepție în clasa test se va crea forțat o astfel de excepție.

Rețineți! 

Cu ajutorul cuvântului rezervat throw avem posibilitatea de a crea explicit un tip de excepție propriu, adică putem crea o instanță excepție, arunca și trata la faza de execuție. Se folosește nemijlocit însoțită de blocul try. Cuvântul rezervat throws ne ajută atunci când dorim să aruncăm, sau transferăm eroarea, astfel încât aceasta să fie tratată de compilator automat, adică eroarea nu va fi tratată de noi explicit într-un bloc try. 

Cuvântul rezervat throws se scrie în semnătura metodei codul căreia ar putea genera o excepție. Acesta va fi urmat de tipul erorii sau tipurile erorilor ce pot fi generate și deasemenea se poate folosi în semnătura metodei main().

Exemplu în care s-a creat propria clasă de excepție. Excepția se va genera forțat atunci cînd utilizatorul va introduce un număr negativ:  

import java.util.*;
 public class Exemplul_3 {
  public static void main(String [] args){
   int nr;
   Scanner in = new Scanner(System.in);
    try{
     nr = in.nextInt();
     if (nr < 0) throw new MyExceptionPozitiv();
     if (nr%2==0) System.out.println("Numar par !");
      else System.out.println("Numar impar !");
   }catch ( InputMismatchException ex){
     System.out.println("Introduceti un numar intreg!!!");
   } catch (MyExceptionPozitiv ex) {
     System.out.println(ex);
} in.close();
}}


class MyExceptionPozitiv extends Exception{
  MyExceptionPozitiv() {}
  public String toString(){
    return "Valoarea introdusa nu este pozitiva"; 

   }

}

Sper că această postare vă este utilă.

Este binevenit orice comentariu!

Să aveți parte de o zi extraordinară !!!!!

Tehnici de tratare a evenimentelor

Salut! În postările anterioare am expus algoritmul general de tratare a evenimentelor. Aici voi expune câteva tehnici care au bază acest algoritm, însă sunt structurate diferit. Din câte am reușit eu să studiez, am depistat trei tehnici. În cazul în care cunoașteți o altă tehnică aș fi recunoscătoare dacă ați descrie în comentariu pentru cititorii blog-ului. 

Deci, un eveniment poate fi tratat: 

1) în aceeași clasă cu ascultătorul: 

import java.awt.*; 

import java.awt.event.*;
class Tehnica_1 extends Frame implements ActionListener{
 TextField tf;

 Tehnica_1(){
  super("Aplicatia mea");
  setLayout(null);
  tf=new TextField();
  tf.setBounds(60,50,150,20);
  Button b=new Button("ok");
  b.setBounds(100,120,80,30);
  b.addActionListener(this);
  add(b);

  add(tf);
  setSize(300,200);
  setVisible(true);

 }
public void actionPerformed(ActionEvent e){
tf.setText("A fost click pe button!"); 

}

public static void main(String args[]){ 

 new Tehnica_1(); 

}

}

2) într-o clasă separată:

//clasa design

import java.awt.*;
class Tehnica_2 extends Frame{
 TextField tf;
 Tehnica_2(){
  super("Aplicatia mea"); setLayout(null);
  tf=new TextField();
  tf.setBounds(60,50,150,20);
  Button b=new Button("click me!");
  b.setBounds(100,120,80,30);
  b.addActionListener(new Extern(this));
  add(b);

  add(tf);
  setSize(300,200); 

  setVisible(true);
}
public static void main(String args[]){ 

 new Tehnica_2(); 

} 

}

//clasa funcționalitate
import java.awt.event.*;
class Extern implements ActionListener{
Tehnica_2 obj;
Extern(Tehnica_2 obj){ this.obj=obj; }
public void actionPerformed(ActionEvent e){
obj.tf.setText("A fost click pe buton");
}

}

3) într-o clasă anonimă: 

import java.awt.*;
import java.awt.event.*;
class Tehnica_3 extends Frame{
TextField tf;
 Tehnica_3 (){
 setLayout(null);
 tf=new TextField(); 

 tf.setBounds(60,50,170,20);
 Button b=new Button("click me"); 

 b.setBounds(50,120,80,30);
 b.addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e){

     tf.setText("a fost click ");

    }
 });
add(b);

add(tf);
setSize(300,300); 

setVisible(true);
}
public static void main(String args[]){ 

   new Tehnica_3 ();

}

}

Indiferent ce tehnică veți utiliza rezultatul va fi același: 

Stimați cititori, în special cei care activează ca programatori, scrieți în comentariu care este metoda utilizată în practică la elaborarea proiectelor reale! Mulțumesc anticipat! 

Sper că această postare vă este utilă.

Este binevenit orice comentariu!

Să aveți parte de o zi extraordinară !!!!!

Clasele Adapter

Salut! După cum am promis anterior, revin cu o postare despre utilitatea claselor Adapter.

Analizând atent ultimul tabel expus în postarea https://musteatadidactic.blogspot.com/2019/02/tratarea-evenimentelor-java-ii.html, veți observa că sunt interfețe ascultător ce conțin două sau mai multe metode. 

Despre interfețe deja cunoaștem că, atunci cînd o clasă implementează o interfață aceasta trebuie să conțină cod pentru toate metodele interfeței. 

Cum procedăm atunci cînd apare necesitatea ca să fie implementată o singură metodă? 

De exemplu, este necesar tratarea evenimentului click pe buton folosind interfața MouseListener. Clasa ascultătoare de eveniment va fi constrânsă să implementeze toate cele cinci metode ale interfeței date. Aici sunt utile clasele Adapter care vor permite tratarea doar a evenimentului necesar printr-o construcție de forma:

Voi rescrie, folosind clasa MouseAdapter, codul sursă din exemplul explicat aici https://musteatadidactic.blogspot.com/2019/02/tratarea-evenimentelor-java-ii.html prin programarea evenimentului mouseClicked() din interfața MouseListener() 

import java.awt.*;

class Aplicatia_Mea2 extends Frame {

 Aplicatia_Mea2(String s){

  super(s);

  setSize(350,100);

  setLayout(new FlowLayout());

  Button b1 = new Button("Ok!");

  b1.addMouseListener(new java.awt.event.MouseAdapter() {

         public void mouseClicked(java.awt.event.MouseEvent evt) {

          setTitle("eveniment generat, capturat si tratat");

         }

        });

  add(b1);

  setVisible(true);

 }

}

public class Test_Adapter {

 public static void main(String[] args) {

     new Aplicatia_Mea2("Exemplu adapter");

}}

Fiecărei interfețe de tip Listener îi corespunde o clasă de tip Adapter.

Sper că această postare vă este utilă.

Este binevenit orice comentariu!

Să aveți parte de o zi extraordinară !!!!!

Tratarea evenimentelor Java (II).

Dacă am privi din punct de vedere al codului, evenimentul nu este altceva decât o metodă care este executată atunci când utilizatorul acționează o componentă de pe suprafața aplicației. 

Dacă vorbim de evenimentul click pe un buton, sau oricare altă componentă, atunci metoda invocată va fi actionPerformed()care aparține interfeței ActionListener. Deci, metodele invocate la generarea unui eveniment fac parte din interfețe specifice evenimentului generat. 

Orice eveniment în Java este o instanță a unei subclase a clasei Event. La executare click pe o componentă buton, se va crea de fapt o instanță a clasei ActionEvent. Amintind principiul moștenirii în Java, o clasă extinde o singură clasă și numai una, în cazul în care clasa cu care lucrăm extinde deja o clasă nu vom putea extinde și clasa evenimentului generat pentru a oferi mecanism de tratare a acestuia. De aceea fiecărei clase de evenimente îi corespunde o interfață ce grupează  evenimentele specifice unui anumit domeniu, numite și interfețe de ascultare sau interfețe listener. Cât despre interfețe, o clasă Java, poate implemente orice număr de interfețe. 

De exemplu, evenimentele tastaturei, sunt de fapt instanțe a clasei KeyEvent căreia îi corespunde interfața KeyListener ce conține mai multe metode de tratare a evenimentelor tastaturei. 

Voi prezenta câteva clase de evenimente și interfețele corespunzătoare acestora, situații când  aceste clase sunt instanțiate, și componente ce pot genera evenimentele grupate de interfețele date: 

Orice clasă care tratează evenimente trebuie să implementeze obligatoriu metodele interfețelor de ascultare sau interfețelor Listener corespunzătoare evenimentelor care le tratează. 

În tabelul de mai jos voi reprezenta metodele conținute de aceste interfețe:

În postarea https://musteatadidactic.blogspot.com/2019/02/tratarea-evenimentelor-java.html am explicat cum are loc tratarea evenimentului click pe o componentă de tip buton. Analogic se respectă și algoritmul de tratare a oricărui alt tip de eveniment. Dacă se va dori tratarea evenimentului generat la selectarea unei opțiuni dintr-o componentă de tip Choice, atunci se va implementa interfața ItemListener și se va supradefini metoda itemStateChanged(). De fapt, codul conținut de această metodă va fi executat la generarea acestui tip de eveniment.

E simplu atunci când se lucrează cu interfețe care conțin o singură metodă. În cazul în care aceasta va conține mai multe metode, ca de exemplu WindowListener, atunci va fi necesar de supradefinit toate metodele interfețelor chiar dacă nu se dorește acest lucru. Orice clasă ce implementează o interfață trebuie să conțină corp, să supradefinească, să facă override, :) :) , după cum menționează elevii mei dragi, la toate metodele interfeței.

Ce facem în cazul în care nu dorim acest lucru?

Ok! Voi veni în zilele următoare cu o postare despre clasele Adapter !

Sper că această postare vă este utilă.

Este binevenit orice comentariu!

Să aveți parte de o zi extraordinară !!!!!

Tratarea evenimentelor Java (I).

Un eveniment este o acțiune a utilizatorului asupra unei componente grafice și reprezintă mecanismul prin care utilizatorul comunică efectiv cu programul. 

De exemplu: 

1) acționarea unui buton;
2) tastarea unei taste;
3) mutarea unei componente cu butonul mouse-ului;
4) închiderea unei ferestre;
5) redimensionarea unei ferestre, ș.a

Toate componentele generează evenimente atunci când utilizatorul acționează asupra acestora într-un anumit mod. 

Evenimentele sunt de diferite tipuri fiecare tip fiind reprezentat de o clasă distinctă. Programatorul nu se va preocupa de generarea evenimentelor, deoarece acestea sunt generate în mod automat atunci cînd utilizatorul interacționează cu aplicația. Însă programatorul trebuie să indice instrucțiunile care vor fi executate în momentul în care apar aceste evenimente. 

Atunci când este lansat un eveniment, acesta este capturat de unul sau mai mulți ascultători. 

Un ascultător este o clasă ce implementează interfețe de tip Listener definite în pachetul java.awt.event și care au ca scop capturarea și tratarea evenimentului generat.

Atunci cînd se dorește tratarea evenimentelor, programatorul trebuie să creeze un obiect ascultător și apoi să îl înregistreze la componenta grafică care a generat evenimentul. 

Înregistrarea se face prin apelarea metodei addXListener(XListener listener) asupra componentei care lansează evenimentul, unde X reprezintă tipul de eveniment pentru care se înregistrează ascultătorul. 

De exemplu : addWindowListener(...), addItemListener(...)

Mecanismul gestionării evenimentelor în Java poate fi reprezentată schematic astfel: 

Componenta reprezintă sursa de evenimente.
Eveniment este generat de o componentă.
Ascultătorul sau Listener-ul captează și tratează evenimentul generat.

Pentru a trata un eveniment se va respecta la general următorul algoritm (pentru exemplificare vom trata evenimentul click cu mouse-ul pe o componentă): 

1. clasa ce conține componenta care va genera evenimentul trebuie să implementeze o interfață Listener, sau să extindă o clasă care deja implementează această interfață: 

public class ClasaMea implements ActionListener { ... }

2. ascultătorul de evenimente se înregistrează la sursa de evenimente prin intermediul metodei addXListener(XListener listener): 

oComponenta.addActionListener(instantaClasaMea); 

3. ascultătorul implementează metodele interfeței de ascultare: 

       public void actionPerformed(ActionEvent e) { 

        ...//codul ce se va executa ca răspuns la eveniment 

       }

Exemplu:

import java.awt.*;

import java.awt.event.*;

class Aplicatia_Mea extends Frame implements ActionListener{

 Aplicatia_Mea(String s){

  super(s);

  setSize(350,100);

  setLayout(new FlowLayout());

  Button b1 = new Button("Ok!");

  b1.addActionListener(this);

  add(b1);

  setVisible(true);

 }

@Override

public void actionPerformed(ActionEvent e) {

 this.setTitle("generat, capturat si tratat");

}}

public class Test_OnLick {

 public static void main(String[] args) {

     new Aplicatia_Mea("Exemplu de eveniment");

}}

Lansată la execuția aplicația va avea aspectul:

După executarea butonul ok!  va fi modificat corespunzător titlul ferestrei:

Aceasta este una din modalitățile prin care putem trata evenimente în Java. Analogic se respectă acești pași și pentru celelate tipuri de evenimente, diferență fiind interfața cu care se lucrează. 

Există și alte tehnici despre care voi expune în una din următoarele postări. La fel și despre alte tipuri de evenimente ce pot fi tratate.

Sper că această postare vă este utilă. 

Este binevenit orice comentariu! 

Să aveți parte de o zi extraordinară !!!!!