C2 - Structura lexicală Java

Setul de caractere
 Limbajului Java lucrează în mod nativ folosind setul de caractere Unicode.
Acesta este un standard internaţional care înlocuieşte vechiul set de caractere
ASCII. Motivul acestei înlocuiri a fost necesitatea de a reprezenta mai mult de
256 de caractere. Setul de caractere Unicode, fiind reprezentat pe 16 biţi are
posibilităţi mult mai mari.

 Java foloseşte setul Unicode în timpul rulării aplicaţiilor ca şi în timpul

compilării acestora.

 În timpul compilării, compilatorul Java acceptă la intrare fişiere sursă care pot
conţine orice caractere Unicode. Se poate lucra şi cu fişiere ASCII obişnuite în
care putem introduce caractere Unicode folosind secvenţe Escape.
Setul de caractere

 Fişierele sursă sunt fişiere care conţin declaraţii şi instrucţiuni Java.

Aceste fişiere trec prin trei etape distincte în timpul citirii lor de
către compilator:

1. Şirul de caractere Unicode sau ASCII, memorat în fişierul sursă

este transformat într-un şir de caractere Unicode.

2. Şirul de caractere Unicode este transformat într-un şir de caractere

în care sunt evidenţiate separat caracterele de intrare faţă de
caracterele de sfârşit de linie.

3. Şirul de caractere de intrare şi de sfârşit de linie este transformat

într-un şir de cuvinte ale limbajului Java.
 Unităţi lexicale
 Unităţile lexicale sunt elementele de bază cu care se construieşte
semantica programelor Java. În şirul de cuvinte de intrare,
unităţile lexicale sunt separate între ele prin comentarii şi spaţii.
Unităţile lexicale în limbajul Java sunt:

 Cuvinte cheie
 Identificatori
 Literali
 Separatori
 Operatori
 Cuvinte cheie

 Cuvintele cheie: sunt secvenţe de caractere ASCII

rezervate de limbaj pentru uzul propriu. Cu ajutorul lor,
Java îşi defineşte unităţile sintactice de bază. Nici un
program nu poate să utilizeze aceste secvenţe altfel decât
în modul în care sunt definite de limbaj.
 Singura excepţie este aceea că nu există nici o
restricţionare a apariţiei cuvintelor cheie în şiruri de
caractere sau comentarii.
 Cuvinte cheie

 abstract  double
 boolean  else
 break
 extends
 byte
 case
 final
 cast  finally
 catch  float
 char  for
 class  future
 const
 generic
 continue
 default  goto
 do  if
 Cuvinte cheie

 implements  operator
 import  outer
 inner  package
 private
 instanceof
 protected
 intinterface
 public
 long
 rest
 native
 return
 new  short
 null  static
 super
 switch
 Cuvinte cheie

 synchronized
 this
 throw
 throws
 transient
 try
 var
 void
 volatile
 while
 byvalue
 Identificatori Java
Toate componentele Java necesită un nume.
Numele utilizate pentru clase, variabile și metode se numesc identificatori.
În Java, există mai multe reguli de reținut despre identificatori. Acestea sunt următoarele :

 Toți identificatorii trebuie să înceapă cu o literă (A la Z sau a până la z), caracter de monedă ($)
sau subliniere (_).

 După primul cararacter, identificatorii pot avea orice combinație de caractere.

 Un cuvânt cheie nu poate fi utilizat ca identificator.

 Cel mai important, identificatorii sunt sensibili la majuscule (case sensitive).

 Exemple de identificatori legali: vârstă, salariu de $, valoare, __1_valoare.

 Exemple de identificatori ilegali: 123abc, -salary.

 Modificatori Java
Ca și în alte limbaje, este posibil să modificați clase, metode etc., folosind modificatori.

Există două categorii de modificatori:

1. Modificatori de acces - implicit, public, protejat, privat (default, public, protected,

private)

2. Modificatori fără acces - final, abstract, strictfp

Vom prezenta mai multe detalii despre modificatori în cursurile următoare.

 Variabile Java
Următoarele sunt tipurile de variabile din Java:

 Variabile locale
 Variabile de clasă (variabile statice)
 Variabile de instanță (variabile nestatice)
 Tablouri (Arrays) Java
Array-urile sunt obiecte care stochează mai multe variabile de același tip.

Cu toate acestea, un tablou în sine este un obiect din heap.

Vom analiza modul de declarare, construcție și inițializare în capitolele

următoare.
 Enum Java
Enum au fost introduse în Java 5.0. Enums restricționează o variabilă să ia
una dintre doar câteva valori predefinite. Valorile din această listă
enumerate se numesc enums.

Cu ajutorul enums se reduc numărul de erori din cod.

Enum pot fi declarate și în cadrul unei clase. Metodele, variabilele,

constructorii pot fi definiți și în cadrul enumerărilor.

De exemplu, dacă luăm în considerare o aplicație pentru un magazin de

sucuri proaspete, ar fi posibil să restricționăm dimensiunea paharului la
dimensiuni mici, medii și mari. Aceasta s-ar asigura că nu ar permite
nimănui să comande alte dimensiuni decât mici, mijlocii sau mari.
 Enum Java
class SucProaspat {
enum DimensiuneSucProaspat { MIC, MEDIU, MARE }
DimensiuneSucProaspat dimensiune;
}

public class SucProaspatTest {

public static void main(String args[]) {

SucProaspat suc = new SucProaspat();
suc.dimensiune = SucProaspat.DimensiuneSucProaspat.MEDIU ;
System.out.println(“Dimensiune: " + suc.dimensiune);
}
}
 Comentarii în Java
Java acceptă comentarii de o singură linie și de mai multe linii, foarte similare
cu C și C ++. Toate caracterele disponibile în orice comentariu sunt
ignorate de compilatorul Java.
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");
}
}
 Moştenire în Java

În Java, clasele pot fi derivate din clase. Practic, dacă trebuie să creați o clasă
nouă și aici este deja o clasă care are o parte din codul pe care îl solicitați,
atunci este posibil să derivați noua dvs. clasă din codul deja existent.

Acest concept vă permite să reutilizați câmpurile și metodele clasei existente

fără a fi necesar să rescrieți codul într-o nouă clasă. În acest scenariu,
clasa existentă se numește superclasă, iar clasa derivată se numește
subclasă.
 Interfeţe în Java

În limbajul Java, o interfață poate fi definită ca un set de reguli între obiecte

privind modul de comunicare între ele.

Interfețele joacă un rol vital atunci când vine vorba de conceptul de moștenire.

O interfață definește metodele pe care o clasă derivată (subclasa) ar trebui să

le utilizeze.

Dar implementarea metodelor depinde în totalitate de subclase.

 Obiecte și clase în Java

Java este un limbaj orientat pe obiecte.

Java acceptă următoarele concepte fundamentale -
 Polimorfismul
 Moştenire
 Încapsularea
 Abstractizarea
 Clase
 Obiecte
 Instanțe
 Metode
Obiect - Obiectele au stări și comportamente. Exemplu: un câine are stări - culoare,
nume, rasa, precum și comportamente - lătrat, mâncat. Un obiect este o instanță a
unei clase.
Clasa - o clasă poate fi definită ca un șablon / model care descrie comportamentul /
starea pe care o suportă obiectul tipului său.
 Obiecte în Java

Dacă avem în vedere lumea reală, putem găsi multe obiecte în jurul nostrum: mașini,
câini, oameni, etc. Toate aceste obiecte au o stare și un comportament.

Dacă luăm în considerare un câine, atunci starea lui este - numele, rasa, culoarea, iar
comportamentul este - lătrat, alergând, etc.

Dacă comparați obiectul software cu un obiect din lumea reală, acestea au

caracteristici foarte similare.

Obiectele software au, de asemenea, o stare și un comportament. Starea unui obiect

software este stocată în câmpuri (fields) și comportamentul este afișat prin metode
(metode).

În dezvoltarea de software, metodele operează pe starea internă a unui obiect, iar

comunicarea obiect-obiect se face prin metode.
 Clase în Java

O clasă este un model din care sunt create obiecte individuale.

Exemplu

public class Caine {

String rasa;
int varsta;
String culoare;

void latra() {
}
void mananca() {
}
void doarme() {
}
}
 Clase în Java

O clasă poate conține oricare dintre următoarele tipuri de variabile.

Variabile locale - Variabilele definite în metode, constructori sau blocuri se numesc

variabile locale. Variabila va fi declarată și inițiată în cadrul metodei, iar variabila
va fi distrusă la finalizarea metodei.

Variabile de instanță - Variabilele de instanță sunt variabile dintr-o clasă, dar în afara
oricărei metode. Aceste variabile sunt inițializate atunci când clasa este instanțiată.
Variabilele de instanță pot fi accesate din interiorul oricărei metode, constructor sau
blocuri din acea anumită clasă.

Variabile de clasă - Variabilele de clasă sunt variabile declarate în cadrul unei clase,
în afara oricărei metode, cu cuvântul cheie static.

În exemplul de mai sus, latra (), mananca () și doarme () sunt metode.

 Constructori în Java

Fiecare clasă are un constructor. Dacă nu scriem în mod explicit un constructor pentru o clasă,
compilatorul Java construiește un constructor implicit pentru acea clasă.

De fiecare dată când este creat un obiect nou, cel puțin un constructor va fi invocat. Principala
regulă a constructorilor este aceea că ar trebui să aibă același nume ca și clasa. O clasă
poate avea mai mult de un constructor.

Exemplu
public class Catelus {
    public Catelus () {
    }

    public Catelus (String nume) {

       // Acest constructor are un singur parametru, nume.
    }
}
 Crearea unui obiect

O clasă este un model pentru obiecte. Deci, practic, un obiect este creat dintr-
o clasă.

În Java, cuvânt cheie new este utilizat pentru a crea obiecte noi.

Există trei pași pentru a creea un obiect dintr-o clasă:

Declarație - Declarație variabilă cu un nume variabil cu un tip de obiect.

Instanțiere - cuvântul cheie new este folosit pentru a crea obiectul.

Inițializare - cuvântul cheie new este urmat de un apel către un constructor.

Acest apel inițializează noul obiect.
 Crearea unui obiect

Exemplu

public class Catelus {

   public Catelus (String name) {
      // Acest constructor are un singur parametru, nume.
      System.out.println ("Numele ei este:" + nume);
   }

   public static void main (String [] args) {

      // Următoarea declarație creaza un obiect CatelusaMea
      Puppy CatelusaMea = new Catelus (“Lola");
   }
}
Dacă compilăm și rulăm programul de mai sus, acesta va produce următorul rezultat:

Numele ei este: Lola

 Accesarea variabilelor și
metodelor de instanță
Variabilele și metodele de instanță sunt accesate prin intermediul obiectelor create. Pentru a
accesa o variabilă de instanță, urmează calea complet calificată -

/ * Creează mai întâi un obiect * /

ObjectReference = constructor nou ();

/ * Apelează o variabilă după cum urmează * /

ObjectReference.variableName;

/ * Puteți apela o metodă de clasă după cum urmează * /

ObjectReference.MethodName ();
 Accesarea variabilelor și
metodelor de instanță
Exemplu
Acest exemplu explică modul de accesare a variabilelor și metodelor de instanță ale unei clase.

public class Catelus {

    int varstaCatelus;

    public Catelus (String nume) {

       // Acest constructor are un singur parametru, nume.
       System.out.println ("Numele este:" + nume);
    }
    public void setVarsta (varsta int) {
       varstaCatelus = Varsta;
    }
    public int getVarsta () {
       System.out.println ("Vârsta cățelușului este:" + varstaCatelus);
       retur varstaCatelus;
    }

   
 Accesarea variabilelor și
metodelor de instanță
    public static void main (String [] args) {
       / * Crearea obiectului * /
       Catelus CatelusaMea = new Catelus (“Lola");
       / * Metoda clasei de apel pentru a stabili vârsta cățelușului * /
       CatelusaMea.setVarsta (2);
       / * Apelați la o altă metodă de clasă pentru a obține vârsta catelusului * /
       CatelusaMea.getVarsta ();
       / * Puteți accesa, de asemenea, variabila de instanță * /
       System.out.println ("Valoare variabilă:" + CatelusaMea.varstaCatelus);
    }
}
   
Dacă compilăm și rulăm programul de mai sus, atunci va produce următorul rezultat

Numele este: Lola

Vârsta cățelușului este: 2
Valoare variabilă: 2
   Reguli de declarare a fișierului
sursă
Aceste reguli sunt esențiale la declararea claselor, a instrucțiunilor de import și a instrucțiunilor de
pachet într-un fișier sursă.

Poate exista o singură clasă publică pe fiecare fișier sursă.

Un fișier sursă poate avea mai multe clase non-publice.

Numele clasei publice trebuie să fie și numele fișierului sursă, care ar trebui să fie anexat de .java
la sfârșit. De exemplu: numele clasei este public class Angajat {}, apoi fișierul sursă ar trebui
să fie ca Angajat.java.

Dacă clasa este definită în interiorul unui pachet, atunci instrucțiunea pachet ar trebui să fie prima
declarație din fișierul sursă.
   Reguli de declarare a fișierului
sursă
Dacă sunt prezente declarații de import, atunci acestea trebuie scrise între declarația pachetului și
declarația de clasă. Dacă nu există declarații de pachet, atunci instrucțiunea de import trebuie
să fie prima linie din fișierul sursă.

Declarațiile de import și de pachet vor implica toate clasele prezente în fișierul sursă. Nu este
posibil să se declare diferite instrucțiuni de import și / sau pachet la diferite clase din fișierul
sursă.

Clasele au mai multe niveluri de acces și există diferite tipuri de clase; clase abstracte, clase
finale, etc. Vom explica despre toate acestea în capitolul modificatori de acces.

În afară de tipurile de clase menționate mai sus, Java mai are câteva clase speciale numite clase
interioare și clase anonime.
 Pachete Java
  
În cuvinte simple, este o modalitate de clasificare a claselor și interfețelor. Atunci când se dezvoltă
aplicații în Java, se vor scrie sute de clase și interfețe, de aceea clasificarea acestor clase
este o necesitate.

Declarații de import
În Java, dacă este dat un nume complet calificat, care include pachetul și numele clasei, atunci
compilatorul poate localiza cu ușurință codul sursă sau clasele. Declarația de import este un
mod de a da locația corespunzătoare astfel încât compilatorul să găsească acea clasă.

De exemplu, următoarea linie ar solicita compilatorului să încarce toate clasele disponibile în

directorul java_installation / java / io –

import java.io.*;
 Exemplu
  
Pentru studiul nostru de caz, vom crea două clase: Angajat și AngajatTest.

Deschideți Notepad și scrieți următorul cod. Clasa Angajat este o clasă publică. Acum, salvați
acest fișier sursă cu numele Angajat.java.

Clasa Angajat are patru variabile de instanță - nume, vârstă, funcție și salariu. Clasa are un
constructor definit în mod explicit, care ia un parametru.
 Exemplu
import java.io.*;
  
public class Angajat {

String nume;
int varsta;
String functie;
double salariu;

// Constructorul clasei Angajat

public Angajat(String nume) {
this.nume = nume;
}
// atribuirea varstei angajatului la variabila varsta.
public void angajVarsta(int angajVarsta) {
varsta = angajVarsta;
}
 Exemplu
/* asignarea functiei in variabila functie */
  
public void angajFunctie(String angajFunctie) {
functie = angajFunctie;
}
/* atribuirea salariului angajatului in variabila salariu */
public void angajSalariu(double angajSalariu) {
salariu = angajSalariu;
}
/* Tiparirea datelor despre Angajat */

public void printAngajat () {

System.out.println("Nume:"+ nume );
System.out.println(“Varsta:" + varsta );
System.out.println(“Functie:" + functie );
System.out.println("Salariu:" + salariu);
}
}
 Exemplu
  
Așa cum am menționat în cursul anterior, procesarea începe de la metoda
principală. Prin urmare, pentru a rula această clasă de angajați ar trebui să
existe o metodă principală și obiectele ar trebui create. Vom crea o clasă
separată pentru aceste sarcini.

Urmează clasa AngajatTest, care creează două instanțe ale clasei Angajat și
invocă metodele pentru fiecare obiect pentru a atribui valori pentru fiecare
variabilă.

Salvați următorul cod în fișierul AngajatTest.java.

 Exemplu
import java.io.*;   
public class AngajatTest {
public static void main(String args[]) {
/* Creaza 2 obiecte folosind constructorul */
Angajat angajat1 = new Angajat(“Popescu Ion");
Angajat angajat2 = new Angajat(“Popa Maria");

// Invocare metode pentru fiecare obiect

angajat1.angajVarsta(28);
angajat1.angajFunctie(“Director");
angajat1.angajSalariu(8000);
angajat1.printAngajat();

angajat2.angajVarsta(40);
angajat2.angajFunctie(“Inginer Productie");
angajat2.angajSalariu(5000);
angajat2.printAngajat();
}
}
 Exemplu
   AngajatTest pentru a vedea rezultatul după cum
Acum, compilați ambele clase și apoi executați
urmează:

OUTPUT

C: \> javac Angajat.java

C: \> javac AngajatTest.java
C: \> java AngajatTest
Nume: Popescu Ion
Varsta: 28
Functie: Director
Salariu: 8000.0
Nume: Popa Maria
Vârsta: 40
Functie: Inginer de Productie
Salariu: 5000.0
   

ÎNTREBĂRI?